yogurt 0.1.1

data/lib/yogurt/code_generator/generated_file.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class GeneratedFile < T::Struct
+      extend T::Sig
+
+      class FileType < T::Enum
+        enums do
+          # File contains the definition of a GraphQL Enum
+          ENUM = new('enum')
+
+          # File contains the definition of a GraphQL operation (ie, a root query result)
+          OPERATION = new('operation')
+
+          # File contains the definition of a GraphQL object result (ie, a non-root query result)
+          OBJECT_RESULT = new('object_result')
+
+          # File contains the definition of a GraphQL input object
+          INPUT_OBJECT = new('input_object')
+        end
+      end
+
+      # The name of the constant that is stored in this file
+      const :constant_name, String
+
+      # Type of constant that is stored in this file
+      const :type, FileType
+
+      # Names of the constants that this file references. If you are not using an
+      # autoloading tool, the files containing these constants need to be `require`'d
+      # at the start of the file.
+      const :dependencies, T::Array[String]
+
+      # The code that defines the constant that is stored in this file
+      const :code, String
+
+      # Full contents of the file
+      sig {returns(String)}
+      def contents
+        <<~STRING
+          # typed: strict
+          # frozen_string_literal: true
+
+          require 'pp'
+
+          #{code}
+        STRING
+      end
+    end
+  end
+end

data/lib/yogurt/code_generator/input_class.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    # Input classes are used for input objects
+    class InputClass < T::Struct
+      extend T::Sig
+      include Utils
+      include DefinedClass
+
+      const :name, String
+      const :arguments, T::Array[VariableDefinition]
+
+      sig {override.returns(T::Array[String])}
+      def dependencies
+        arguments.map(&:dependency).compact
+      end
+
+      sig {override.returns(String)}
+      def to_ruby
+        extract = []
+        props = []
+        serializers = []
+        arguments.sort.each do |definition|
+          props << "prop #{definition.name.inspect}, #{definition.signature}"
+          extract << "#{definition.name} = self.#{definition.name}"
+          serializers.push(<<~STRING.strip)
+            #{definition.graphql_name.inspect} => #{definition.serializer.strip},
+          STRING
+        end
+
+        <<~STRING
+          class #{name} < T::Struct
+            extend T::Sig
+
+            #{indent(props.join("\n"), 1).strip}
+
+            sig {returns(T::Hash[String, T.untyped])}
+            def serialize
+              #{indent(extract.join("\n"), 2).strip}
+
+              {
+                #{indent(serializers.join("\n"), 3).strip}
+              }
+            end
+          end
+        STRING
+      end
+    end
+  end
+end

data/lib/yogurt/code_generator/leaf_class.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    # Leaf classes are generated for the inner types of query results.
+    class LeafClass < T::Struct
+      include DefinedClass
+      extend T::Sig
+      include Utils
+
+      const :name, String
+      const :schema, GRAPHQL_SCHEMA
+      const :graphql_type, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
+      prop :defined_methods, T::Array[DefinedMethod]
+      prop :dependencies, T::Array[String]
+
+      # Adds the defined methods to the ones that are already defined in the class
+      sig {params(extra_methods: T::Array[DefinedMethod]).void}
+      def merge_defined_methods(extra_methods)
+        own_methods = defined_methods.map {|dm| [dm.name, dm]}.to_h
+        extra_methods.each do |extra|
+          own = own_methods[extra.name]
+          if own.nil?
+            own_methods[extra.name] = extra
+          elsif !own.merge?(extra)
+            raise "Cannot merge method #{extra.inspect} into #{own.inspect}"
+          end
+        end
+
+        self.defined_methods = own_methods.values
+      end
+
+      sig {override.returns(String)}
+      def to_ruby
+        pretty_print = generate_pretty_print(defined_methods)
+
+        dynamic_methods = <<~STRING.strip
+          #{defined_methods.map(&:to_ruby).join("\n")}
+          #{pretty_print}
+        STRING
+
+        <<~STRING
+          class #{name}
+            extend T::Sig
+            include Yogurt::QueryResult
+
+            #{indent(possible_types_constant(schema, graphql_type), 1).strip}
+
+            sig {params(result: Yogurt::OBJECT_TYPE).void}
+            def initialize(result)
+              @result = T.let(result, Yogurt::OBJECT_TYPE)
+            end
+
+            sig {override.returns(Yogurt::OBJECT_TYPE)}
+            def raw_result
+              @result
+            end
+
+            #{indent(typename_method(schema, graphql_type), 1).strip}
+
+            #{indent(dynamic_methods, 1).strip}
+          end
+        STRING
+      end
+    end
+  end
+end

data/lib/yogurt/code_generator/operation_declaration.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class OperationDeclaration < T::Struct
+      const :declaration, QueryDeclaration
+      const :operation_name, String
+      const :variables, T::Array[GraphQL::Language::Nodes::VariableDefinition]
+    end
+  end
+end

data/lib/yogurt/code_generator/root_class.rb

@@ -0,0 +1,130 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    # Root classes are generated for the root of a GraphQL query.
+    class RootClass < T::Struct
+      include DefinedClass
+      extend T::Sig
+      include Utils
+
+      const :name, String
+      const :schema, GRAPHQL_SCHEMA
+      const :operation_name, String
+      const :graphql_type, T.untyped # rubocop:disable Sorbet/ForbidUntypedStructProps
+      const :query_container, QueryContainer::CONTAINER
+      const :defined_methods, T::Array[DefinedMethod]
+      const :variables, T::Array[VariableDefinition]
+      const :dependencies, T::Array[String]
+
+      sig {override.returns(String)}
+      def to_ruby
+        pretty_print = generate_pretty_print(defined_methods)
+        declaration = query_container.fetch_query(operation_name)
+        original_query = declaration.query_text
+        parsed_query = GraphQL.parse(original_query)
+        reprinted_query = GraphQL::Language::Printer.new.print(parsed_query)
+
+        dynamic_methods = <<~STRING.strip
+          #{defined_methods.map(&:to_ruby).join("\n")}
+          #{pretty_print}
+        STRING
+
+        <<~STRING
+          class #{name} < Yogurt::Query
+            extend T::Sig
+            include Yogurt::QueryResult
+            include Yogurt::ErrorResult
+
+            SCHEMA = T.let(#{schema.name}, Yogurt::GRAPHQL_SCHEMA)
+            OPERATION_NAME = T.let(#{operation_name.inspect}, String)
+            QUERY_TEXT = T.let(<<~'GRAPHQL', String)
+              #{indent(reprinted_query, 2).strip}
+            GRAPHQL
+            #{indent(possible_types_constant(schema, graphql_type), 1).strip}
+
+            #{indent(execute_method, 1).strip}
+
+            sig {params(data: Yogurt::OBJECT_TYPE, errors: T.nilable(T::Array[Yogurt::OBJECT_TYPE])).void}
+            def initialize(data, errors)
+              @result = T.let(data, Yogurt::OBJECT_TYPE)
+              @errors = T.let(errors, T.nilable(T::Array[Yogurt::OBJECT_TYPE]))
+            end
+
+            sig {override.returns(Yogurt::OBJECT_TYPE)}
+            def raw_result
+              @result
+            end
+
+            #{indent(typename_method(schema, graphql_type), 1).strip}
+
+            sig {override.returns(T.nilable(T::Array[Yogurt::OBJECT_TYPE]))}
+            def errors
+              @errors
+            end
+
+            #{indent(dynamic_methods, 1).strip}
+          end
+        STRING
+      end
+
+      sig {returns(String)}
+      def execute_method
+        executor = Yogurt.registered_schemas.fetch(schema)
+        options_type = executor.options_type_alias.name
+        signature_params = ["options: #{options_type}"]
+
+        params = if options_type.start_with?("T.nilable", "T.untyped")
+          ["options=nil"]
+        else
+          ["options"]
+        end
+
+        variable_extraction = if variables.any?
+          serializers = []
+
+          variables.sort.each do |variable|
+            if variable.signature.start_with?("T.nilable")
+              params.push("#{variable.name}: nil")
+            else
+              params.push("#{variable.name}:")
+            end
+
+            signature_params.push("#{variable.name}: #{variable.signature}")
+            serializers.push(<<~STRING.strip)
+              #{variable.graphql_name.inspect} => #{variable.serializer.strip},
+            STRING
+          end
+
+          <<~STRING
+            {
+              #{indent(serializers.join("\n"), 1).strip}
+            }
+          STRING
+        else
+          "nil"
+        end
+
+        <<~STRING
+          sig do
+            params(
+              #{indent(signature_params.join(",\n"), 2).strip}
+            ).returns(T.any(T.attached_class, Yogurt::ErrorResult::OnlyErrors))
+          end
+          def self.execute(#{params.join(', ')})
+            raw_result = Yogurt.execute(
+              query: QUERY_TEXT,
+              schema: SCHEMA,
+              operation_name: OPERATION_NAME,
+              options: options,
+              variables: #{indent(variable_extraction, 2).strip}
+            )
+
+            from_result(raw_result)
+          end
+        STRING
+      end
+    end
+  end
+end

data/lib/yogurt/code_generator/type_wrapper.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class TypeWrapper < T::Enum
+      enums do
+        NILABLE = new
+        ARRAY = new
+      end
+    end
+  end
+end

data/lib/yogurt/code_generator/typed_input.rb

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class TypedInput < T::Struct
+      const :signature, String
+      const :serializer, String
+      const :dependency, T.nilable(String)
+    end
+  end
+end

data/lib/yogurt/code_generator/typed_output.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class TypedOutput < T::Struct
+      # The signature to put in the sorbet type
+      const :signature, String
+
+      # Converter function to use for the return result.
+      # This assumes that a local variable named `raw_value` has the
+      # value to be converted.
+      const :deserializer, String
+    end
+  end
+end

data/lib/yogurt/code_generator/utils.rb

@@ -0,0 +1,140 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    module Utils
+      extend T::Sig
+      extend self
+
+      sig {params(schema: GRAPHQL_SCHEMA, graphql_type: T.untyped).returns(String)}
+      def typename_method(schema, graphql_type)
+        possible_types = schema.possible_types(graphql_type)
+
+        if possible_types.size == 1
+          <<~STRING
+            sig {override.returns(String)}
+            def __typename
+              #{possible_types.fetch(0).graphql_name.inspect}
+            end
+          STRING
+        else
+          <<~STRING
+            sig {override.returns(String)}
+            def __typename
+              raw_result["__typename"]
+            end
+          STRING
+        end
+      end
+
+      sig {params(schema: GRAPHQL_SCHEMA, graphql_type: T.untyped).returns(String)}
+      def possible_types_constant(schema, graphql_type)
+        possible_types = schema
+          .possible_types(graphql_type)
+          .map(&:graphql_name)
+          .sort
+          .map(&:inspect)
+
+        single_line = possible_types.join(', ')
+        if single_line.size <= 80
+          <<~STRING.strip
+            POSSIBLE_TYPES = T.let(
+              [#{single_line}],
+              T::Array[String]
+            )
+          STRING
+        else
+          multi_line = possible_types.join(",\n")
+          <<~STRING.strip
+            POSSIBLE_TYPES = T.let(
+              [
+                #{indent(multi_line, 2).strip}
+              ].freeze,
+              T::Array[String]
+            )
+          STRING
+        end
+      end
+
+      sig {params(camel_cased_word: String).returns(String)}
+      def underscore(camel_cased_word)
+        return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+
+        word = camel_cased_word.to_s.gsub("::", "/")
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      sig {params(term: String).returns(String)}
+      def camelize(term)
+        string = term.to_s
+        string = string.sub(/^[a-z\d]*/, &:capitalize)
+        string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) {"#{Regexp.last_match(1)}#{T.must(Regexp.last_match(2)).capitalize}"}
+        string.gsub!("/", "::")
+        string
+      end
+
+      sig {params(string: String, amount: Integer).returns(String)}
+      def indent(string, amount)
+        return string if amount.zero?
+
+        padding = '  ' * amount
+
+        buffer = T.unsafe(String).new("", capacity: string.size)
+        string.each_line do |line|
+          buffer << padding if line.size > 1 || line != "\n"
+          buffer << line
+        end
+
+        buffer
+      end
+
+      sig {params(desired_name: String).returns(Symbol)}
+      def generate_method_name(desired_name)
+        base_desired_name = desired_name
+        escaping_level = 0
+
+        while PROTECTED_NAMES.include?(desired_name)
+          escaping_level += 1
+          desired_name = "#{base_desired_name}#{'_' * escaping_level}"
+        end
+
+        desired_name.to_sym
+      end
+
+      sig {params(methods: T::Array[DefinedMethod]).returns(String)}
+      def generate_pretty_print(methods)
+        inspect_lines = methods.map do |dm|
+          <<~STRING
+            p.comma_breakable
+            p.text(#{dm.name.to_s.inspect})
+            p.text(': ')
+            p.pp(#{dm.name})
+          STRING
+        end
+
+        object_group = <<~STRING.strip
+          p.breakable
+          p.text('__typename')
+          p.text(': ')
+          p.pp(__typename)
+
+          #{inspect_lines.join("\n\n")}
+        STRING
+
+        <<~STRING
+          sig {override.params(p: PP::PPMethods).void}
+          def pretty_print(p)
+            p.object_group(self) do
+              #{indent(object_group, 2).strip}
+            end
+          end
+        STRING
+      end
+    end
+  end
+end