graphql_migrate_execution 0.0.2 → 1.0.1

data/lib/graphql_migrate_execution/resolver_method.rb

@@ -15,13 +15,19 @@ module GraphqlMigrateExecution
       @calls_class = false
       @calls_dataloader = false
       @dataloader_call = false
+      @uses_current_path = false
+      @dataload_association = nil
+      @dataload_record = nil
+      @dataload_record_using = nil
+      @dataload_record_find_by = nil
+      @return_expressions = nil
     end
 
     attr_reader :name, :node, :parameter_names, :self_sends
 
-    attr_reader :source_class_node, :source_arg_nodes, :load_arg_node, :dataload_association
+    attr_reader :source_class_node, :source_arg_nodes, :load_arg_node, :dataload_association, :dataload_record, :dataload_record_using, :dataload_record_find_by
 
-    attr_accessor :calls_object, :calls_context, :calls_class, :calls_dataloader
+    attr_accessor :calls_object, :calls_context, :calls_class, :calls_dataloader, :uses_current_path
 
     attr_accessor :dataloader_call
 
@@ -42,6 +48,7 @@ module GraphqlMigrateExecution
       calls_to_self.delete(:dataload_association)
       calls_to_self.delete(:dataload_record)
       calls_to_self.delete(:dataload)
+      calls_to_self.delete(:dataload_all)
 
       # Global-ish methods:
       calls_to_self.delete(:raise)
@@ -67,6 +74,22 @@ module GraphqlMigrateExecution
               assoc_sym = assoc_arg.unescaped.to_sym
               @dataload_association = assoc_sym == name ? true : assoc_sym
             end
+          when :dataload_record
+            if (record_args = call_node.arguments.arguments) &&
+                (record_arg = record_args.first) &&
+                (record_arg.is_a?(Prism::ConstantReadNode) || record_arg.is_a?(Prism::ConstantPathNode)) &&
+                (using_arg = record_args[1]) &&
+                # Must be `object.{something}`
+                (using_arg.is_a?(Prism::CallNode)) &&
+                (using_arg.receiver.is_a?(Prism::CallNode) && using_arg.receiver.name == :object)
+              @dataload_record = record_arg.full_name
+              @dataload_record_using = using_arg.name
+
+              if (kwargs = record_args.last).is_a?(Prism::KeywordHashNode) && (find_by_kwarg = kwargs.elements.find { |el| el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "find_by" })
+                find_by_node = find_by_kwarg.value
+                @dataload_record_find_by = find_by_node.unescaped.to_sym # Assumes a SymbolNode
+              end
+            end
           else
             if (source_call = call_node.receiver) # eg dataloader.with(...).load(...)
               @source_class_node = source_call.arguments.arguments.first
@@ -78,15 +101,16 @@ module GraphqlMigrateExecution
           input_is_object = @load_arg_node.is_a?(Prism::CallNode) && @load_arg_node.name == :object
           # Guess whether these args are free of runtime context:
           shortcutable_source_args = @source_arg_nodes && (@source_arg_nodes.empty? || (@source_arg_nodes.all? { |a| Visitor.constant_node?(a) }))
-          if @source_class_node.is_a?(Prism::ConstantPathNode) && shortcutable_source_args && input_is_object
+          source_ref_is_constant = @source_class_node.is_a?(Prism::ConstantPathNode) || @source_class_node.is_a?(Prism::ConstantReadNode)
+          if source_ref_is_constant && shortcutable_source_args && input_is_object
             DataloaderShorthand
           else
             case call_node.name
             when :load, :request, :dataload
               DataloaderAll
-            when :load_all, :request_all, :dataload_record
+            when :load_all, :request_all, :dataload_all
               DataloaderBatch
-            when :dataload_association
+            when :dataload_association, :dataload_record
               DataloaderShorthand
             else
               DataloaderManual
@@ -101,5 +125,56 @@ module GraphqlMigrateExecution
         NotImplemented
       end
     end
+
+    def returns_hash?
+      return_expressions.all? { |exp_node| exp_node.is_a?(Prism::HashNode) || (exp_node.is_a?(Prism::CallNode) && exp_node.name == :new && exp_node.receiver.is_a?(Prism::ConstantReadNode) && exp_node.receiver.name == :Hash) }
+    end
+
+    def return_expressions
+      if @return_expressions.nil?
+        @return_expressions = []
+        find_return_expressions(@node)
+      end
+      @return_expressions
+    end
+
+    def returns_string_hash?
+      return_expressions.any? { |exp_node| exp_node.is_a?(Prism::HashNode) && exp_node.elements.size > 0 && exp_node.elements.all? { |el| el.key.is_a?(Prism::StringNode) } }
+    end
+
+    private
+
+    def find_return_expressions(node)
+      case node
+      when Prism::DefNode
+        find_return_expressions(node.body)
+      when Prism::StatementsNode
+        find_return_expressions(node.body.last)
+      when Prism::IfNode # TODO else, `?`, case
+        find_return_expressions(node.statements)
+        find_return_expressions(node.subsequent)
+      when Prism::ElseNode, Prism::WhenNode
+        find_return_expressions(node.statements)
+      when Prism::UnlessNode
+        find_return_expressions(node.statements)
+        find_return_expressions(node.else_clause)
+      when Prism::CaseNode
+        node.conditions.each do |cond_node|
+          find_return_expressions(cond_node)
+        end
+      when Prism::ReturnNode
+        find_return_expressions(node.arguments.first)
+      when Prism::LocalVariableReadNode
+        if (lv_write_node = @node.body.body.find { |n| n.is_a?(Prism::LocalVariableWriteNode) && n.name == node.name })
+          find_return_expressions(lv_write_node.value)
+        else
+          # Couldn't find assignment :'(
+          @return_expressions << node
+        end
+      else
+        # This is an expression that produces a return value
+        @return_expressions << node
+      end
+    end
   end
 end

data/lib/graphql_migrate_execution/strategy.rb

@@ -1,66 +1,152 @@
 # frozen_string_literal: true
+require_relative "./action"
+
 module GraphqlMigrateExecution
   class Strategy
-    def add_future(field_definition, new_source)
+    include Action::Colorize
+    def initialize(action, field_definitions)
+      @action = action
+      @migration = action.migration
+      @filepath = action.filepath
+      @action_method = @migration.action_method
+      @message = action.message
+      @result_source = action.result_source
+      @field_definitions = field_definitions
+    end
+
+    def migrate(field_definition)
+    end
+
+    def cleanup(field_definition)
     end
 
-    def remove_legacy(field_definition, new_source)
+    def run
+      case @action_method
+      when :analyze
+        @message << "\n#{colorize("#{colorize(self.class.strategy_name, self.class.color)} (#{@field_definitions.size})", :BOLD)}:\n"
+        max_path = @field_definitions.map { |f| f.path.size }.max + 2
+        @field_definitions.each do |field_defn|
+          name = field_defn.path.ljust(max_path)
+          @message << "\n  - #{name} (#{field_defn.resolve_mode.inspect} -> #{field_defn.resolve_mode_key.inspect}) @ #{@filepath}:#{field_defn.source_line}"
+        end
+        @message << "\n"
+      when :migrate,  :cleanup
+        indent_size = @action.strategy_name_padding + 1
+        indent = " " * indent_size
+        indent2_size = @action.field_name_padding
+        @message << "\n#{colorize(self.class.strategy_name.ljust(indent_size), self.class.color)}"
+        first = true
+        @field_definitions.each do |field_defn|
+          @message << "#{first ? "" : "#{indent}"}#{field_defn.path.ljust(indent2_size)}  @ #{@filepath}:#{field_defn.source_line}\n"
+          first = false
+          public_send(@action_method, field_defn)
+        end
+      end
+    end
+
+    def self.strategy_name
+      name.split("::").last
     end
 
     class << self
       attr_accessor :color
     end
 
+    # These methods conflict with built-in class methods,
+    # so when migrating them, prefix them.
+    METHODS_TO_RENAME = [
+      "name",
+      "fields",
+      "arguments",
+    ]
+
+    def self.prefix_if_necessary(method_name)
+      name_s = method_name.to_s
+      if METHODS_TO_RENAME.include?(name_s)
+        "resolve_#{method_name}"
+      else
+        name_s
+      end
+    end
+
     private
 
-    def inject_resolve_keyword(new_source, field_definition, keyword)
+    def inject_resolve_keyword(field_definition, keyword)
       value = field_definition.future_resolve_shorthand.inspect
-      inject_field_keyword(new_source, field_definition, keyword, value)
+      inject_field_keyword(field_definition, keyword, value)
     end
 
-    def inject_field_keyword(new_source, field_definition, keyword, value)
+    def inject_field_keyword(field_definition, keyword, value)
       field_definition_source = field_definition.source
-      new_definition_source = if field_definition_source[/ [a-z_]+:/] # Does it already have keywords?
-        field_definition_source.sub(/(field.+?)((?: do)|(?: {)|$)/, "\\1, #{keyword}: #{value}\\2")
+      pair = "#{keyword}: #{value}"
+      if field_definition_source.include?(pair)
+        # Pass, don't re-add it
+      elsif field_definition_source.include?("#{keyword}:")
+        warn "Can't re-inject #{keyword} because it's already present in the definition:\n\n#{field_definition_source}"
       else
-        field_definition_source + ", #{keyword}: #{value}"
+        new_definition_source = if field_definition_source[/ [a-z_]+:/] # Does it already have keywords?
+          field_definition_source.sub(/(field.+?)((?:,$)|(?: do)|(?: {)|$)/, "\\1, #{pair}\\2")
+        elsif (block_node = field_definition.node.block)
+          block_source = block_node.location.slice
+          field_definition_source.sub(" " + block_source, ", #{pair} #{block_source}")
+        else
+          field_definition_source + ", #{pair}"
+        end
+        @result_source.sub!(field_definition_source, new_definition_source)
       end
-      new_source.sub!(field_definition_source, new_definition_source)
     end
 
 
-    def remove_field_keyword(new_source, field_definition, keyword)
+    def remove_field_keyword(field_definition, keyword)
       field_definition_source = field_definition.source
       new_definition_source = field_definition_source.sub(/, #{keyword}: \S+(,|$)/, "\\1")
-      new_source.sub!(field_definition_source, new_definition_source)
+      @result_source.sub!(field_definition_source, new_definition_source)
     end
 
-    def replace_resolver_method(new_source, field_definition, new_params)
+    def replace_resolver_method(field_definition, new_params)
       resolver_method = field_definition.resolver_method
-      method_name = resolver_method.name
+      old_method_name = resolver_method.name.to_s
+      new_method_name = self.class.prefix_if_necessary(old_method_name)
       old_method = resolver_method.source
-      new_class_method = old_method
-        .sub("def ", 'def self.')
+
+      method_prefix = field_definition.type_definition.is_interface ? "def #{new_method_name}" : "def self.#{new_method_name}"
+      new_class_method = old_method.sub("def #{old_method_name}", method_prefix)
 
       if resolver_method.parameter_names.empty?
-        new_class_method.sub!(method_name.to_s, "#{method_name}(#{new_params})")
+        new_class_method.sub!(new_method_name, "#{new_method_name}(#{new_params})")
       else
-        new_class_method.sub!("def self.#{method_name}(", "def self.#{method_name}(#{new_params}, ")
+        new_class_method.sub!("#{method_prefix}(", "#{method_prefix}(#{new_params}, ")
+      end
+
+      if field_definition.type_definition.is_interface
+        indent = new_class_method[/\A +/]
+        new_class_method.gsub!(/^#{indent}/, "#{indent}  ")
+        new_class_method = "#{indent}resolver_methods do\n#{new_class_method}#{indent}end\n"
       end
 
       old_lines = old_method.split("\n")
-      new_body = old_lines.first[/^ +/] + "  self.class.#{method_name}(#{new_params}#{resolver_method.parameter_names.map { |n| ", #{n}: #{n}"}.join})"
-      new_inst_method = [old_lines.first, new_body, old_lines.last].join("\n")
+      forward_previous_params = resolver_method.parameter_names.map { |n| ", #{n}: #{n}"}.join
+      if old_lines.size == 1
+        # TODO doesn't support `def ... =` syntax
+        previous_def = /def [^;]+;/.match(old_method)
+        new_inst_method = old_lines.first[/^ +/] + "#{previous_def} self.class.#{new_method_name}(#{new_params}#{forward_previous_params}); end"
+      else
+        new_body = old_lines.first[/^ +/] + "  self.class.#{new_method_name}(#{new_params}#{forward_previous_params})"
+        new_inst_method = [old_lines.first, new_body, old_lines.last].join("\n")
+      end
 
       new_double_definition = new_class_method + "\n" + new_inst_method + "\n"
-      new_source.sub!(old_method, new_double_definition)
+      @result_source.sub!(old_method, new_double_definition)
     end
 
-    def remove_resolver_method(new_source, field_definition)
-      src_pattern = /(\n*)(#{Regexp.quote(field_definition.resolver_method.source)})(\n*)/
-      new_source.sub!(src_pattern) do
-        # $2 includes a newline, too
-        "#{$1.length > 1 ? "\n" : ""}#{$3.length > 0 ? "\n" : ""}"
+
+    def remove_resolver_method(field_definition)
+      if field_definition.resolver_method
+        src_pattern = /(\n*)(#{Regexp.quote(field_definition.resolver_method.source)})(\n*)/
+        @result_source.sub!(src_pattern) do
+          # $2 includes a newline, too
+          "#{$1.length > 1 ? "\n" : ""}#{$3.length > 0 ? "\n" : ""}"
+        end
       end
     end
   end

data/lib/graphql_migrate_execution/type_definition.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 module GraphqlMigrateExecution
   class TypeDefinition
-    def initialize(name)
+    def initialize(name, migration)
       @name = name
+      @migration = migration
       @field_definitions = {}
       @resolver_methods = {}
+      @is_resolver = false
+      @is_interface
     end
 
+    attr_accessor :is_resolver, :migration, :is_interface
+
     attr_reader :resolver_methods, :name, :field_definitions
 
     def field_definition(name, node)
@@ -16,5 +21,13 @@ module GraphqlMigrateExecution
     def resolver_method(name, node)
       @resolver_methods[name] = ResolverMethod.new(name, node)
     end
+
+    def returns_hash?
+      @resolver_methods.each_value.first.returns_hash?
+    end
+
+    def returns_string_hash?
+      @resolver_methods.each_value.first.returns_string_hash?
+    end
   end
 end

data/lib/graphql_migrate_execution/unsupported_current_path.rb

@@ -0,0 +1,8 @@
+module GraphqlMigrateExecution
+  # These use `context[:current_path]` or `context.current_path` which isn't supported. Refactor these fields then try migrating again.
+  #
+  # Open an issue on GraphQL-Ruby's GitHub repo to discuss further.
+  class UnsupportedCurrentPath < Strategy
+    self.color = :RED
+  end
+end

data/lib/graphql_migrate_execution/unsupported_extra.rb

@@ -0,0 +1,8 @@
+module GraphqlMigrateExecution
+  # These use a field `extra` which isn't supported. Remove this configuration and refactor the field, then try migrating again.
+  #
+  # (Currently, only `:ast_node` and `:lookahead` are currently supported. Please open an issue on GraphQL-Ruby if this is a problem for you.)
+  class UnsupportedExtra < Strategy
+    self.color = :RED
+  end
+end

data/lib/graphql_migrate_execution/version.rb

@@ -1,3 +1,3 @@
 module GraphqlMigrateExecution
-  VERSION = "0.0.2"
+  VERSION = "1.0.1"
 end

data/lib/graphql_migrate_execution/visitor.rb

@@ -7,6 +7,7 @@ module GraphqlMigrateExecution
       @type_definition_stack = []
       @current_field_definition = nil
       @current_resolver_method = nil
+      @is_public = true
     end
 
     def visit_class_node(node)
@@ -23,6 +24,7 @@ module GraphqlMigrateExecution
 
     def visit_module_node(node)
       td = @type_definitions[node.name]
+      td.is_interface = true
       @type_definition_stack << td
       super
     ensure
@@ -37,7 +39,7 @@ module GraphqlMigrateExecution
             when "hash_key"
               @current_field_definition.resolve_mode ||= :hash_key
               @current_field_definition.hash_key = get_keyword_value(assoc.value)
-            when "resolver"
+            when "resolver", "mutation", "subscription"
               @current_field_definition.resolve_mode ||= :resolver
               @current_field_definition.resolver = get_keyword_value(assoc.value)
             when "method"
@@ -49,10 +51,15 @@ module GraphqlMigrateExecution
             when "dig"
               @current_field_definition.resolve_mode ||= :dig
               @current_field_definition.dig = get_keyword_value(assoc.value)
-            when "resolve_each", "resolve_static", "resolve_batch"
+            when "resolve_each", "resolve_static", "resolve_batch", "resolve_legacy_instance_method"
               # These should override any other keywords that are discovered
               @current_field_definition.resolve_mode = :already_migrated
               @current_field_definition.already_migrated = { assoc.key.unescaped.to_sym => get_keyword_value(assoc.value) }
+            when "fallback_value"
+              if !assoc.value.is_a?(Prism::NilNode)
+                @current_field_definition.resolve_mode ||= :fallback_value
+                @current_field_definition.fallback_value = self.class.source_for_constant_node(assoc.value)
+              end
             else
               # fallback_value,  connection, extensions, extras, resolver, mutation, subscription
               @current_field_definition.unknown_options << assoc.key.unescaped
@@ -64,15 +71,18 @@ module GraphqlMigrateExecution
     end
 
     def visit_call_node(node)
-      if node.receiver.nil? && node.name == :field
+      if node.receiver.nil? && node.name == :field && node.arguments
         first_arg = node.arguments.arguments.first # rubocop:disable Development/ContextIsPassedCop
-        if first_arg.is_a?(Prism::SymbolNode)
+        if first_arg.is_a?(Prism::SymbolNode) && (td = @type_definition_stack.last)
           field_name = first_arg.unescaped
-          td = @type_definition_stack.last
           @current_field_definition = td.field_definition(field_name, node)
         else
           warn "GraphQL-Ruby warning: Skipping unrecognized field definition: #{node.inspect}"
         end
+      elsif node.receiver.nil? && ((node.name == :private) || (node.name == :protected))
+        @is_public = false
+      elsif node.receiver.nil? && node.name == :public
+        @is_public = true
       elsif @current_resolver_method
         if node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
           @current_resolver_method.self_sends.add(node.name)
@@ -89,6 +99,15 @@ module GraphqlMigrateExecution
         case node.name
         when :dataloader, :dataload, :dataload_association, :dataload_record, :dataload_all
           @current_resolver_method.calls_dataloader = true
+        when :current_path
+          if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context
+            @current_resolver_method.uses_current_path = true
+          end
+        when :[]
+          if node.receiver.is_a?(Prism::CallNode) && node.receiver.name == :context &&
+              (arg = node.arguments.arguments.first).is_a?(Prism::SymbolNode) && (arg.unescaped == "current_path")
+            @current_resolver_method.uses_current_path = true
+          end
         end
       end
       super
@@ -99,22 +118,39 @@ module GraphqlMigrateExecution
     end
 
     def visit_def_node(node)
-      if node.receiver.nil?
-        td = @type_definition_stack.last
-        @current_resolver_method = td.resolver_method(node.name, node)
-      end
+      if @is_public && (td = @type_definition_stack.last)
+        if node.receiver.nil?
+          @current_resolver_method = td.resolver_method(node.name, node)
+        end
+
+        if node.name == :resolve && td.resolver_methods.size == 1
+          td.is_resolver = true
+        elsif td.is_resolver && td.resolver_methods.size > 1
+          td.is_resolver = false
+        end
 
-      body = node.body.body
-      if body.length == 1 && (call_node = body.first).is_a?(Prism::CallNode)
-        case call_node.name
-        when :load, :request, :load_all, :request_all
-          if (call_node2 = call_node.receiver).is_a?(Prism::CallNode) && call_node2.name == :with
+        body = case node.body
+        when Prism::StatementsNode
+          node.body.body
+        when Prism::BeginNode
+          node.body.statements.body
+        when nil
+          nil
+        else
+          raise ArgumentError, "Unexpected DefNode body for `def #{node.name}`: #{node.body.class}"
+        end
+
+        if body && @current_resolver_method && body.length == 1 && (call_node = body.first).is_a?(Prism::CallNode)
+          case call_node.name
+          when :load, :request, :load_all, :request_all
+            if (call_node2 = call_node.receiver).is_a?(Prism::CallNode) && call_node2.name == :with
+              @current_resolver_method.dataloader_call = true
+            end
+          when :dataload_record, :dataload_association, :dataload, :dataload_all
             @current_resolver_method.dataloader_call = true
+          else
+            # not a single dataloader call
           end
-        when :dataload_record, :dataload_association, :dataload
-          @current_resolver_method.dataloader_call = true
-        else
-          # not a single dataloader call
         end
       end
       super

data/lib/graphql_migrate_execution.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
+require "prism"
 require "graphql_migrate_execution/action"
-require "graphql_migrate_execution/add_future"
-require "graphql_migrate_execution/remove_legacy"
-require "graphql_migrate_execution/analyze"
+require "graphql_migrate_execution/migration"
 require "graphql_migrate_execution/field_definition"
 require "graphql_migrate_execution/resolver_method"
 require "graphql_migrate_execution/type_definition"
@@ -10,6 +9,8 @@ require "graphql_migrate_execution/visitor"
 require "graphql_migrate_execution/strategy"
 require "graphql_migrate_execution/implicit"
 require "graphql_migrate_execution/do_nothing"
+require "graphql_migrate_execution/fallback_value"
+require "graphql_migrate_execution/resolve_batch"
 require "graphql_migrate_execution/resolve_each"
 require "graphql_migrate_execution/resolve_static"
 require "graphql_migrate_execution/not_implemented"
@@ -17,35 +18,11 @@ require "graphql_migrate_execution/dataloader_all"
 require "graphql_migrate_execution/dataloader_batch"
 require "graphql_migrate_execution/dataloader_manual"
 require "graphql_migrate_execution/dataloader_shorthand"
+require "graphql_migrate_execution/hash_key"
+require "graphql_migrate_execution/unsupported_extra"
+require "graphql_migrate_execution/unsupported_current_path"
 require "graphql_migrate_execution/not_implemented"
 require "irb"
 
 module GraphqlMigrateExecution
-  class Migration
-    def initialize(glob, concise: false, migrate: false, cleanup: false, only: nil, implicit: nil, colorable: IRB::Color.colorable?)
-      @glob = glob
-      @skip_description = concise
-      @colorable = colorable
-      @only = only
-      @implicit = implicit
-      @action_class = if migrate
-        AddFuture
-      elsif cleanup
-        RemoveLegacy
-      else
-        Analyze
-      end
-    end
-
-    attr_reader :skip_description, :colorable
-
-
-    def run
-      Dir.glob(@glob).each do |filepath|
-        source = File.read(filepath)
-        file_migrate = @action_class.new(self, filepath, source)
-        puts file_migrate.run
-      end
-    end
-  end
 end