graphql-doctor 0.1.0

data/lib/graphql/doctor/source/file_visitor.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require_relative "index"
+require_relative "name_mangler"
+
+module GraphQL
+  module Doctor
+    module Source
+      class FileVisitor < Prism::Visitor
+        LOOP_METHODS = %i[each map collect filter select reject times upto downto].freeze
+
+        attr_reader :index
+
+        def initialize(path:, source:, comments: [])
+          super()
+          @path = path
+          @source = source
+          @owners = []
+          @visibilities = []
+          @dynamic_reason = nil
+          @current_field = nil
+          @forced_visibility = nil
+          @singleton_depth = 0
+          @index = Index.new(comments: comments.map { |comment| source_comment(comment) })
+        end
+
+        def visit_class_node(node)
+          visit_namespace(node, :class)
+        end
+
+        def visit_module_node(node)
+          visit_namespace(node, :module)
+        end
+
+        def visit_if_node(node)
+          with_dynamic(:conditional) { super }
+        end
+
+        def visit_unless_node(node)
+          with_dynamic(:conditional) { super }
+        end
+
+        def visit_case_node(node)
+          with_dynamic(:conditional) { super }
+        end
+
+        def visit_while_node(node)
+          with_dynamic(:loop) { super }
+        end
+
+        def visit_until_node(node)
+          with_dynamic(:loop) { super }
+        end
+
+        def visit_for_node(node)
+          with_dynamic(:loop) { super }
+        end
+
+        def visit_singleton_class_node(node)
+          return unless owner && node.expression.is_a?(Prism::SelfNode)
+
+          @singleton_depth += 1
+          @visibilities << :public
+          begin
+            visit(node.body) if node.body
+          ensure
+            @visibilities.pop
+            @singleton_depth -= 1
+          end
+        end
+
+        def visit_call_node(node)
+          return visit_visibility(node) if %i[private protected public].include?(node.name)
+          return visit_class_visibility(node) if %i[private_class_method public_class_method].include?(node.name)
+          return with_dynamic(:loop) { super } if LOOP_METHODS.include?(node.name) && node.block
+          return visit_schema_dsl(node) if %i[field argument implements].include?(node.name)
+
+          case node.name
+          when :include, :extend then record_dynamic(node, node.name)
+          else
+            record_dynamic(node, :field) if node.name.to_s.end_with?("_field")
+            node.block ? with_dynamic(:metaprogramming) { super } : super
+          end
+        end
+
+        def visit_def_node(node)
+          parameters = node.parameters
+          required = []
+          optional = []
+          defaults = {}
+          parameter_locations = {}
+
+          Array(parameters&.keywords).each do |parameter|
+            name = parameter.name
+            parameter_locations[name] = parameter_location(parameter.name_loc)
+            if parameter.is_a?(Prism::RequiredKeywordParameterNode)
+              required << name
+            else
+              optional << name
+              defaults[name] = parameter.value.slice
+            end
+          end
+
+          rest = parameters&.keyword_rest
+          @index.method_definitions << IR::MethodDefinition.new(
+            owner: owner,
+            name: node.name,
+            visibility: @forced_visibility || visibility,
+            singleton: !node.receiver.nil? || @singleton_depth.positive?,
+            required_keywords: required,
+            optional_keywords: optional,
+            keyword_defaults: defaults,
+            accepts_keyword_rest: rest.is_a?(Prism::KeywordRestParameterNode),
+            forbids_keywords: rest.is_a?(Prism::NoKeywordsParameterNode),
+            positionals: positional_parameters(parameters),
+            required_positionals: positional_count(parameters, :requireds) + positional_count(parameters, :posts),
+            optional_positionals: positional_count(parameters, :optionals),
+            accepts_positional_rest: parameters&.rest.is_a?(Prism::RestParameterNode),
+            location: location(node.name_loc),
+            parameter_locations: parameter_locations,
+            dynamic: !!@dynamic_reason || rest.is_a?(Prism::ForwardingParameterNode)
+          )
+        end
+
+        private
+
+        def visit_schema_dsl(node)
+          return visit_children(node) unless dsl_call?(node)
+
+          case node.name
+          when :field then visit_field(node)
+          when :argument then visit_argument(node)
+          when :implements then visit_implements(node)
+          end
+        end
+
+        def visit_namespace(node, kind)
+          path = constant_path(node.constant_path)
+          previous_singleton_depth = @singleton_depth
+          @singleton_depth = 0
+          @owners << path
+          @visibilities << :public
+          @index.types << IR::TypeDefinition.new(
+            owner: owner,
+            superclass: node.respond_to?(:superclass) ? node.superclass&.slice : nil,
+            kind: kind,
+            location: location(node.constant_path.location),
+            confidence: @dynamic_reason ? :dynamic : :certain
+          )
+          visit(node.body) if node.body
+        ensure
+          @visibilities.pop
+          @owners.pop
+          @singleton_depth = previous_singleton_depth
+        end
+
+        def visit_field(node)
+          arguments = Array(node.arguments&.arguments)
+          name_node = arguments[0]
+          return record_dynamic(node, :field, @dynamic_reason || :non_literal_name) unless literal_name(name_node)
+
+          field = IR::FieldDefinition.new(
+            owner: owner,
+            graphql_name: NameMangler.graphql_name(literal_name(name_node)),
+            ruby_name: literal_name(name_node).to_sym,
+            type_expression: arguments[1]&.slice,
+            options: keyword_options(arguments),
+            arguments: [],
+            block_location: node.block && location(node.block.location),
+            definition_location: location(name_node.value_loc),
+            confidence: @dynamic_reason ? :dynamic : :certain
+          )
+          @index.fields << field
+          record_dynamic(node, :field) if @dynamic_reason
+
+          previous = @current_field
+          @current_field = field
+          visit_children(node)
+          field.arguments.concat(@index.arguments.select do |argument|
+            argument.owner == field.owner && argument.field_name == field.ruby_name
+          end)
+        ensure
+          @current_field = previous
+        end
+
+        def visit_argument(node)
+          arguments = Array(node.arguments&.arguments)
+          name_node = arguments[0]
+          return record_dynamic(node, :argument, @dynamic_reason || :non_literal_name) unless literal_name(name_node)
+
+          options = keyword_options(arguments)
+          required = options.fetch(:required, true)
+          definition = IR::ArgumentDefinition.new(
+            owner: owner,
+            field_name: @current_field&.ruby_name,
+            graphql_name: NameMangler.graphql_name(literal_name(name_node)),
+            ruby_name: literal_name(name_node).to_sym,
+            type_expression: arguments[1]&.slice,
+            required: required,
+            default_value: options.fetch(:default_value, :no_default),
+            loads: options[:loads],
+            as: options[:as],
+            prepare: options[:prepare],
+            extras: options.fetch(:extras, []),
+            definition_location: location(name_node.value_loc),
+            confidence: @dynamic_reason ? :dynamic : :certain
+          )
+          @index.arguments << definition
+          record_dynamic(node, :argument) if @dynamic_reason
+          visit_children(node)
+        end
+
+        def visit_implements(node)
+          Array(node.arguments&.arguments).each do |argument|
+            @index.interfaces << IR::InterfaceImplementation.new(
+              owner: owner, interface: argument.slice, location: location(argument.location)
+            )
+          end
+          record_dynamic(node, :implements) if @dynamic_reason
+          visit_children(node)
+        end
+
+        def visit_visibility(node)
+          definitions = Array(node.arguments&.arguments).grep(Prism::DefNode)
+          if definitions.any?
+            previous = @forced_visibility
+            @forced_visibility = node.name
+            definitions.each { |definition| visit(definition) }
+            @forced_visibility = previous
+            return
+          end
+
+          names = Array(node.arguments&.arguments).filter_map { |argument| literal_name(argument)&.to_sym }
+          if names.empty?
+            @visibilities[-1] = node.name
+          else
+            @index.method_definitions.each do |method|
+              next unless method.owner == owner && method.singleton == @singleton_depth.positive?
+
+              method.visibility = node.name if names.include?(method.name)
+            end
+          end
+        end
+
+        def visit_class_visibility(node)
+          visibility = node.name == :private_class_method ? :private : :public
+          definitions = Array(node.arguments&.arguments).grep(Prism::DefNode)
+          if definitions.any?
+            previous = @forced_visibility
+            @forced_visibility = visibility
+            definitions.each { |definition| visit(definition) }
+            @forced_visibility = previous
+          end
+
+          names = Array(node.arguments&.arguments).filter_map { |argument| literal_name(argument)&.to_sym }
+          @index.method_definitions.each do |method|
+            method.visibility = visibility if method.owner == owner && method.singleton && names.include?(method.name)
+          end
+        end
+
+        def keyword_options(arguments)
+          hash = arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
+          return {} unless hash
+
+          hash.elements.each_with_object({}) do |element, values|
+            next unless element.is_a?(Prism::AssocNode)
+
+            key = literal_name(element.key)&.to_sym
+            values[key] = literal_value(element.value) if key
+          end
+        end
+
+        def literal_value(node)
+          case node
+          when Prism::SymbolNode then node.unescaped.to_sym
+          when Prism::StringNode then node.unescaped
+          when Prism::TrueNode then true
+          when Prism::FalseNode then false
+          when Prism::NilNode then nil
+          when Prism::IntegerNode, Prism::FloatNode then node.value
+          when Prism::ArrayNode then node.elements.map { |element| literal_value(element) }
+          else node.slice
+          end
+        end
+
+        def literal_name(node)
+          node.unescaped if node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+        end
+
+        def field_receiver?(receiver)
+          receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        end
+
+        def dsl_call?(node)
+          owner && field_receiver?(node.receiver)
+        end
+
+        def positional_parameters(parameters)
+          return [] unless parameters
+
+          (parameters.requireds + parameters.optionals + parameters.posts).map do |parameter|
+            parameter.respond_to?(:name) ? parameter.name : parameter.slice
+          end
+        end
+
+        def positional_count(parameters, name)
+          parameters ? parameters.public_send(name).length : 0
+        end
+
+        def constant_path(node)
+          path = node.slice.delete_prefix("::")
+          return path if @owners.empty? || node.slice.start_with?("::")
+          return path if path == owner || path.start_with?("#{owner}::")
+
+          owner_parts = owner.split("::")
+          if path.split("::").first == owner_parts.last
+            return (owner_parts[0...-1] + [path]).reject(&:empty?).join("::")
+          end
+
+          "#{owner}::#{path}"
+        end
+
+        def owner
+          @owners.last
+        end
+
+        def visibility
+          @visibilities.last || :public
+        end
+
+        def with_dynamic(reason)
+          previous = @dynamic_reason
+          @dynamic_reason = reason
+          yield
+        ensure
+          @dynamic_reason = previous
+        end
+
+        def record_dynamic(node, kind, reason = @dynamic_reason || :metaprogramming)
+          @index.dynamics << IR::DynamicDefinition.new(
+            owner: owner, kind: kind, reason: reason, location: location(node.location)
+          )
+        end
+
+        def source_comment(comment)
+          IR::SourceComment.new(text: comment.slice, location: location(comment.location))
+        end
+
+        def visit_children(node)
+          node.each_child_node { |child| visit(child) }
+        end
+
+        def parameter_location(prism_location)
+          value = location(prism_location)
+          return value unless @source.byteslice(prism_location.end_offset - 1, 1) == ":"
+
+          Location.new(**value.to_h, end_column: value.end_column - 1, end_offset: value.end_offset - 1)
+        end
+
+        def location(prism_location)
+          Location.from_prism(@path, prism_location)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/doctor/source/index.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../ir"
+
+module GraphQL
+  module Doctor
+    module Source
+      INDEX_COLLECTIONS = %i[
+        types fields arguments method_definitions interfaces dynamics comments diagnostics
+      ].freeze
+      SYMBOL_TAG = "__graphql_doctor_symbol__"
+
+      Index = Struct.new(
+        *INDEX_COLLECTIONS,
+        keyword_init: true
+      ) do
+        def initialize(**attributes)
+          super(**INDEX_COLLECTIONS.to_h { |name| [name, Array(attributes[name])] })
+        end
+
+        def merge(other)
+          self.class.new(**INDEX_COLLECTIONS.to_h { |name| [name, public_send(name) + other.public_send(name)] })
+        end
+
+        def to_h
+          INDEX_COLLECTIONS.to_h { |name| [name, public_send(name).map { |value| serialize(value) }] }
+        end
+
+        def freeze!
+          INDEX_COLLECTIONS.each do |name|
+            public_send(name).each { |value| deep_freeze(value) }
+            public_send(name).freeze
+          end
+          freeze
+        end
+
+        def self.from_h(hash)
+          raise ArgumentError, "Invalid source index" unless serialized_index?(hash)
+
+          values = hash.transform_keys(&:to_sym)
+          new(
+            types: Array(values[:types]).map { |value| record(IR::TypeDefinition, value, :location) },
+            fields: Array(values[:fields]).map { |value| field(value) },
+            arguments: Array(values[:arguments]).map { |value| argument(value) },
+            method_definitions: Array(values[:method_definitions]).map { |value| method_definition(value) },
+            interfaces: Array(values[:interfaces]).map do |value|
+              record(IR::InterfaceImplementation, value, :location)
+            end,
+            dynamics: Array(values[:dynamics]).map { |value| record(IR::DynamicDefinition, value, :location) },
+            comments: Array(values[:comments]).map { |value| record(IR::SourceComment, value, :location) },
+            diagnostics: Array(values[:diagnostics]).map { |value| Diagnostic.from_h(value) }
+          )
+        end
+
+        class << self
+          private
+
+          def serialized_index?(hash)
+            hash.is_a?(Hash) && INDEX_COLLECTIONS.all? do |name|
+              key = hash.key?(name) ? name : name.to_s
+              hash.key?(key) && hash[key].is_a?(Array)
+            end
+          end
+
+          def field(value)
+            values = symbolize(value)
+            values[:ruby_name] = values[:ruby_name]&.to_sym
+            values[:confidence] = values[:confidence]&.to_sym
+            values[:options] = symbolize(values[:options] || {})
+            values[:arguments] = Array(values[:arguments]).map { |argument_value| argument(argument_value) }
+            %i[block_location definition_location].each { |key| values[key] = location(values[key]) }
+            IR::FieldDefinition.new(**values)
+          end
+
+          def argument(value)
+            values = symbolize(value)
+            %i[ruby_name required as confidence].each do |key|
+              values[key] = values[key]&.to_sym if values[key].is_a?(String)
+            end
+            values[:field_name] = values[:field_name]&.to_sym
+            values[:definition_location] = location(values[:definition_location])
+            IR::ArgumentDefinition.new(**values)
+          end
+
+          def method_definition(value)
+            values = symbolize(value)
+            %i[name visibility].each { |key| values[key] = values[key]&.to_sym }
+            %i[required_keywords optional_keywords].each do |key|
+              values[key] = Array(values[key]).map(&:to_sym)
+            end
+            values[:keyword_defaults] = symbolize(values[:keyword_defaults] || {})
+            locations = symbolize(values[:parameter_locations] || {})
+            values[:parameter_locations] = locations.transform_values do |location_value|
+              location(location_value)
+            end
+            values[:location] = location(values[:location])
+            IR::MethodDefinition.new(**values)
+          end
+
+          def record(type, value, *location_keys)
+            values = symbolize(value)
+            values[:kind] = values[:kind]&.to_sym if values.key?(:kind)
+            values[:confidence] = values[:confidence]&.to_sym if values.key?(:confidence)
+            values[:reason] = values[:reason]&.to_sym if values.key?(:reason)
+            location_keys.each { |key| values[key] = location(values[key]) }
+            type.new(**values)
+          end
+
+          def location(value)
+            value && Location.from_h(value)
+          end
+
+          def symbolize(value)
+            deserialize(value).transform_keys(&:to_sym)
+          end
+
+          def deserialize(value)
+            case value
+            when Array then value.map { |item| deserialize(item) }
+            when Hash
+              return value.fetch(SYMBOL_TAG).to_sym if value.keys == [SYMBOL_TAG]
+
+              value.transform_values { |item| deserialize(item) }
+            else value
+            end
+          end
+        end
+
+        private
+
+        def serialize(value)
+          hash = value.to_h
+          hash.transform_values { |item| serialize_value(item) }
+        end
+
+        def serialize_value(value)
+          case value
+          when Location then value.to_h
+          when Symbol then {SYMBOL_TAG => value.to_s}
+          when Struct then serialize(value)
+          when Array then value.map { |item| serialize_value(item) }
+          when Hash then value.transform_values { |item| serialize_value(item) }
+          else value
+          end
+        end
+
+        def deep_freeze(value)
+          case value
+          when Array
+            value.each { |item| deep_freeze(item) }
+          when Hash
+            value.each do |key, item|
+              deep_freeze(key)
+              deep_freeze(item)
+            end
+          when Struct
+            value.each_pair { |_name, item| deep_freeze(item) }
+          end
+          value.freeze
+        end
+      end
+    end
+  end
+end

data/lib/graphql/doctor/source/loader.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "../cache"
+require_relative "file_visitor"
+
+module GraphQL
+  module Doctor
+    module Source
+      class Loader
+        def initialize(root: Dir.pwd, config: Config.new, cache: true)
+          @root = File.expand_path(root)
+          @config = config
+          @cache = cache && Cache.new(directory: File.join(@root, ".graphql-doctor/cache"))
+          @config_digest = Digest::SHA256.hexdigest(JSON.generate(config.values))
+        end
+
+        def load(paths = [], jobs: 1)
+          files = discover(paths)
+          return Index.new.freeze! if files.empty?
+
+          indexes = parse_files(files, jobs.to_i)
+          indexes.reduce(Index.new, &:merge).freeze!
+        end
+
+        def discover(paths = [])
+          patterns = paths.empty? ? @config["include"] : paths
+          included = patterns.flat_map { |pattern| expand(pattern) }.uniq
+          excluded = @config["exclude"].flat_map { |pattern| expand(pattern) }
+          (included - excluded).select { |path| File.file?(path) && File.extname(path) == ".rb" }.sort
+        end
+
+        private
+
+        def parse_files(files, jobs)
+          workers = jobs.clamp(1, files.length)
+          return files.map { |path| parse(path) } if workers == 1
+
+          pairs = if Process.respond_to?(:fork) && RUBY_ENGINE == "ruby"
+                    parse_with_forks(files, workers)
+                  else
+                    parse_with_threads(files, workers)
+                  end
+          indexes = pairs.to_h
+          files.map { |path| indexes.fetch(path) }
+        end
+
+        def parse_with_threads(files, workers)
+          queue = Queue.new
+          files.each { |path| queue << path }
+          Array.new(workers) do
+            Thread.new do
+              results = []
+              until queue.empty?
+                path = queue.pop(true)
+                results << [path, parse(path)]
+              end
+              results
+            rescue ThreadError
+              results
+            end
+          end.flat_map(&:value)
+        end
+
+        def parse_with_forks(files, workers)
+          chunks = Array.new(workers) { [] }
+          files.each_with_index { |path, index| chunks[index % workers] << path }
+          children = chunks.map { |chunk| fork_worker(chunk) }
+          children.flat_map do |pid, reader|
+            response = JSON.parse(reader.read)
+            reader.close
+            Process.wait(pid)
+            raise Error, response["message"] if response["status"] == "error"
+
+            response.fetch("indexes").map do |entry|
+              [entry.fetch("path"), Index.from_h(entry.fetch("index"))]
+            end
+          end
+        end
+
+        def fork_worker(files)
+          reader, writer = IO.pipe
+          pid = Process.fork do
+            reader.close
+            begin
+              indexes = files.map { |path| {"path" => path, "index" => parse(path).to_h} }
+              writer.write(JSON.generate("status" => "ok", "indexes" => indexes))
+            rescue StandardError => e
+              writer.write(JSON.generate("status" => "error", "message" => e.message))
+            ensure
+              writer.close
+            end
+            exit! 0
+          end
+          writer.close
+          [pid, reader]
+        end
+
+        def expand(pattern)
+          path = File.expand_path(pattern, @root)
+          return Dir.glob(File.join(path, "**/*.rb")) if File.directory?(path)
+          return [path] if File.file?(path)
+
+          Dir.glob(path)
+        end
+
+        def parse(path)
+          return @cache.fetch(path, config_digest: @config_digest) { |source| parse_uncached(path, source) } if @cache
+
+          parse_uncached(path)
+        end
+
+        def parse_uncached(path, source = nil)
+          source ||= File.binread(path)
+          result = Prism.parse(source)
+          relative_path = path.delete_prefix("#{@root}/")
+          return parse_failure(relative_path, result) if result.failure?
+
+          visitor = FileVisitor.new(path: relative_path, source: source, comments: result.comments)
+          visitor.visit(result.value)
+          visitor.index
+        rescue SystemCallError => e
+          Index.new(diagnostics: [diagnostic("GQLD104", e.message, path, 1, 0)])
+        end
+
+        def parse_failure(path, result)
+          diagnostics = result.errors.map do |error|
+            diagnostic("GQLD104", error.message, path, error.location.start_line, error.location.start_column)
+          end
+          Index.new(diagnostics: diagnostics)
+        end
+
+        def diagnostic(code, message, path, line, column)
+          Diagnostic.new(
+            code: code,
+            severity: "error",
+            message: message,
+            location: Location.new(
+              path: path, start_line: line, end_line: line, start_column: column,
+              end_column: column + 1, start_offset: 0, end_offset: 1
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/doctor/source/name_mangler.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Doctor
+    module Source
+      module NameMangler
+        module_function
+
+        def graphql_name(ruby_name)
+          string = ruby_name.to_s
+          return string if string == "_" || !string.include?("_")
+
+          camelized = string.split("_").map(&:capitalize).join
+          camelized[0] = camelized[0].downcase
+          prefix = string[/\A_+/]
+          prefix ? "#{prefix}#{camelized}" : camelized
+        end
+
+        def keyword(ruby_name, loads: nil, as: nil)
+          return as.to_sym if as
+
+          name = ruby_name.to_s
+          return name.delete_suffix("_ids").sub(/([^s])\z/, "\\1s").to_sym if loads && name.end_with?("_ids")
+          return name.delete_suffix("_id").to_sym if loads && name.end_with?("_id")
+
+          name.to_sym
+        end
+      end
+    end
+  end
+end