graphql-client 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 852686ecf24561871545329aeb4868baaccb99de
-  data.tar.gz: 2bd0845ad82f0ba555497e0a46c315a9d8a6fa0f
+  metadata.gz: 8414ab402cf8454eb7d34081edc3c17fff0611de
+  data.tar.gz: 2a1351fe377f4e9999b9a0c5cfedd04081240753
 SHA512:
-  metadata.gz: 58701e7031146155bcf9584bf61cdbee25f6ac9bf61121eccd5e915970624d2755aef071f18c781d38fcbf3ca1878fccff4f22d33b7dbe3c537598a597658f23
-  data.tar.gz: 8dfe674b8d2c39233fcdfd533e8ea516c010e0cecb7be38fb01c2128f76dc466e61e7dd334e0dff36e810465d9e9f6064d7c5f9969de9e65e081fa0dba0bc9ea
+  metadata.gz: b1b30fc5a6c9f06f03a8c3ed9e69614bb1f7d3a0cbd449bb72a2077d34a154a6b2b48bd3d0b988997b2d59716941a3121fe2958f5948dff6afcce17c779c3cdd
+  data.tar.gz: dfbe13c52c3bd8d9df76129b8de2ec7f4fe2bb430c1788f9d77966c8a75f57d8fcbdc973e280239f763fba1d6976be8babaffdb86590b0da35819b40e1c0fb26

data/lib/graphql/client.rb

@@ -1,100 +1,14 @@
-require "active_support/inflector"
 require "graphql"
-require "graphql/client/const_proxy"
+require "graphql/client/document"
+require "graphql/client/fragment"
+require "graphql/client/node"
 require "graphql/client/query_result"
-require "graphql/language/mutator"
-require "graphql/language/nodes/deep_freeze_ext"
-require "graphql/language/operation_slice"
-require "graphql/relay/parser"
+require "graphql/client/query"
 
 module GraphQL
-  class Client
-    class Error < StandardError; end
-    class ValidationError < Error; end
-
-    attr_reader :schema
-
-    def initialize(schema:)
-      @schema = schema
-      @definitions = []
-    end
-
-    class Definition
-      def initialize(name:, client:, source:)
-        @name = name
-        @client = client
-        @_nodes = @client._parse(@name, source)
-        @query_result = GraphQL::Client::QueryResult.wrap(@_nodes.first, name: name)
-      end
-
-      attr_reader :_nodes
-
-      def operation_name
-        if op = @_nodes.find { |d| d.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
-          op.name
-        else
-          nil
-        end
-      end
-
-      def document
-        @document ||= Language::OperationSlice.slice(@client.document, operation_name).deep_freeze
-      end
-
-      def new(*args)
-        @query_result.new(*args)
-      end
-    end
-
-    def parse(str)
-      definition = ConstProxy.new { |name| Definition.new(client: self, name: name, source: str) }
-      @definitions << definition
-      definition
-    end
-
-    def _parse(name, str)
-      str = str.strip
-
-      str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)(\.([a-zA-Z0-9_]+))?/) { |m|
-        const_name, fragment_name = $1, $4
-        nodes = ActiveSupport::Inflector.constantize(const_name)._nodes
-
-        fragment_name = fragment_name ?
-          nodes.find { |n| n.name.end_with?(fragment_name) }.name : # XXX
-          nodes.first.name
-
-        "...#{fragment_name}"
-      }
-
-      doc = GraphQL::Relay::Parser.parse(str)
-
-      mutator = GraphQL::Language::Mutator.new(doc)
-
-      aliases = {}
-      doc.definitions.each do |definition|
-        aliases[definition.name] = (name.split("::") << definition.name).compact.join("__")
-      end
-      mutator.rename_definitions(aliases)
-
-      # TODO: Make this __typename injection optional
-      mutator.prepend_selection(GraphQL::Language::Nodes::Field.new(name: "__typename").deep_freeze)
-
-      doc.definitions.map(&:deep_freeze)
-    end
-
-    def document
-      GraphQL::Language::Nodes::Document.new(definitions: @definitions.flat_map(&:_nodes)).deep_freeze
-    end
-
-    def validate!
-      validator = StaticValidation::Validator.new(schema: @schema)
-      query = Query.new(@schema, document: document)
-
-      validator.validate(query).fetch(:errors).each do |error|
-        raise ValidationError, error["message"]
-      end
-
-      nil
+  module Client
+    class << self
+      attr_accessor :schema
     end
   end
 end

data/lib/graphql/client/document.rb

@@ -0,0 +1,48 @@
+require "graphql"
+require "graphql/client/fragment"
+require "graphql/client/node"
+require "graphql/client/query"
+require "graphql/language/nodes/deep_freeze_ext"
+require "graphql/language/nodes/inject_selection_ext"
+require "graphql/language/nodes/replace_fragment_spread_ext"
+require "graphql/language/nodes/validate_ext"
+
+module GraphQL
+  module Client
+    class Document < Node
+      def self.parse(str, schema: GraphQL::Client.schema)
+        str = str.strip
+        str, fragments = scan_interpolated_fragments(str)
+
+        document = GraphQL.parse(str)
+        document = document.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
+
+        document.definitions.each do |definition|
+          fragments[definition.name.to_sym] = definition if definition.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+        end
+
+        document = document.replace_fragment_spread(fragments)
+        document = document.replace_fragment_spread(fragments) # XXX: Multiple pass
+
+        document.definitions.inject({}) do |doc, definition|
+          name = definition.name.to_sym
+
+          case definition
+          when GraphQL::Language::Nodes::OperationDefinition
+            query = GraphQL::Client::Query.new(definition.deep_freeze, fragments.values).freeze
+            query.node.validate!(schema: schema) if schema
+            doc[name] = query
+
+          when GraphQL::Language::Nodes::FragmentDefinition
+            definition = GraphQL::Language::Nodes::InlineFragment.new(type: definition.type, directives: definition.directives, selections: definition.selections)
+            fragment = GraphQL::Client::Fragment.new(definition.deep_freeze, fragments.values).freeze
+            fragment.node.validate!(schema: schema) if schema
+            doc[name] = fragment
+          end
+
+          doc
+        end
+      end
+    end
+  end
+end

data/lib/graphql/client/fragment.rb

@@ -0,0 +1,32 @@
+require "graphql"
+require "graphql/client/node"
+require "graphql/language/nodes/deep_freeze_ext"
+require "graphql/language/nodes/inject_selection_ext"
+require "graphql/language/nodes/replace_fragment_spread_ext"
+require "graphql/language/nodes/validate_ext"
+
+module GraphQL
+  module Client
+    class Fragment < Node
+      def self.parse(str, schema: GraphQL::Client.schema)
+        str = str.strip
+        str, fragments = scan_interpolated_fragments(str)
+
+        if str.start_with?("fragment")
+          str = str.sub(/^fragment on /, "fragment __anonymous__ on ")
+          doc = GraphQL.parse(str)
+          doc = doc.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
+          doc = doc.replace_fragment_spread(fragments)
+          fragment = doc.definitions.first
+          node = GraphQL::Language::Nodes::InlineFragment.new(type: fragment.type, directives: fragment.directives, selections: fragment.selections)
+        else
+          raise ArgumentError, "expected string to be a fragment:\n#{str}"
+        end
+
+        fragment = new(node.deep_freeze, fragments.values).freeze
+        fragment.node.validate!(schema: schema) if schema
+        fragment
+      end
+    end
+  end
+end

data/lib/graphql/client/node.rb

@@ -0,0 +1,36 @@
+require "active_support/inflector"
+require "graphql"
+require "graphql/language/nodes/query_result_class_ext"
+
+module GraphQL
+  module Client
+    class Node
+      def self.scan_interpolated_fragments(str)
+        fragments, index = {}, 1
+        str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) { |m|
+          index += 1
+          name = "__fragment#{index}__"
+          fragments[name.to_sym] = ActiveSupport::Inflector.constantize($1).node
+          "...#{name}"
+        }
+        return str, fragments
+      end
+
+      attr_reader :node
+
+      attr_reader :fragments
+
+      attr_reader :type
+
+      def initialize(node, fragments)
+        @node = node
+        @fragments = fragments
+        @type = node.query_result_class(shadow: fragments)
+      end
+
+      def new(*args)
+        type.new(*args)
+      end
+    end
+  end
+end

data/lib/graphql/client/query.rb

@@ -0,0 +1,30 @@
+require "graphql"
+require "graphql/client/node"
+require "graphql/language/nodes/deep_freeze_ext"
+require "graphql/language/nodes/inject_selection_ext"
+require "graphql/language/nodes/replace_fragment_spread_ext"
+require "graphql/language/nodes/validate_ext"
+
+module GraphQL
+  module Client
+    class Query < Node
+      def self.parse(str, schema: GraphQL::Client.schema)
+        str = str.strip
+        str, fragments = scan_interpolated_fragments(str)
+
+        if str.start_with?("query")
+          doc = GraphQL.parse(str)
+          doc = doc.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
+          doc = doc.replace_fragment_spread(fragments)
+          node = doc.definitions.first
+        else
+          raise ArgumentError, "expected string to be a query:\n#{str}"
+        end
+
+        query = new(node.deep_freeze, fragments.values).freeze
+        query.node.validate!(schema: schema) if schema
+        query
+      end
+    end
+  end
+end

data/lib/graphql/client/query_result.rb

@@ -1,38 +1,15 @@
-require "active_support/inflector"
 require "graphql"
-require "set"
+require "active_support/inflector"
 
 module GraphQL
-  class Client
+  module Client
     class QueryResult
-      # Internal: Get QueryResult class for result of query.
-      #
-      # Returns subclass of QueryResult or nil.
-      def self.wrap(node, name: nil)
-        fields = {}
-
-        node.selections.each do |selection|
-          case selection
-          when Language::Nodes::FragmentSpread
-          when Language::Nodes::Field
-            field_name = selection.alias || selection.name
-            field_klass = selection.selections.any? ? wrap(selection, name: "#{name}.#{field_name}") : nil
-            fields[field_name] ? fields[field_name] |= field_klass : fields[field_name] = field_klass
-          when Language::Nodes::InlineFragment
-            wrap(selection, name: name).fields.each do |fragment_name, klass|
-              fields[fragment_name.to_s] ? fields[fragment_name.to_s] |= klass : fields[fragment_name.to_s] = klass
-            end
-          end
-        end
-
-        define(name: name, source_node: node, fields: fields)
+      def self.fields
+        @fields
       end
 
-      # Internal
-      def self.define(name:, source_node:, fields: {})
+      def self.define(fields: {})
         Class.new(self) do
-          @name = name
-          @source_node = source_node
           @fields = {}
 
           fields.each do |field, type|
@@ -85,20 +62,8 @@ module GraphQL
         end
       end
 
-      def self.source_node
-        @source_node
-      end
-
-      def self.fields
-        @fields
-      end
-
-      def self.name
-        @name || super || GraphQL::Client::QueryResult.name
-      end
-
       def self.inspect
-        "#<#{self.name} fields=#{@fields.keys.inspect}>"
+        "#<GraphQL::Client::QueryResult fields=#{@fields.keys.inspect}>"
       end
 
       def self.cast(obj)
@@ -106,14 +71,6 @@ module GraphQL
         when Hash
           new(obj)
         when QueryResult
-          spreads = Set.new(obj.class.source_node.selections.select { |s| s.is_a?(GraphQL::Language::Nodes::FragmentSpread) }.map(&:name))
-
-          if !spreads.include?(self.source_node.name)
-            message = "couldn't cast #{obj.inspect} to #{self.inspect}\n\n"
-            suggestion = "\n  ...#{name || "YourFragment"} # SUGGESTION"
-            message << GraphQL::Language::Generation.generate(obj.class.source_node).sub(/\n}$/, "#{suggestion}\n}")
-            raise TypeError, message
-          end
           cast(obj.to_h)
         when Array
           obj.map { |e| cast(e) }
@@ -142,8 +99,7 @@ module GraphQL
             new_fields[name] = value
           end
         end
-        # TODO: Picking first source node seems error prone
-        define(name: self.name, source_node: self.source_node, fields: new_fields)
+        define(fields: new_fields)
       end
 
       attr_reader :data
@@ -151,7 +107,7 @@ module GraphQL
 
       def inspect
         ivars = (self.class.fields.keys - [:__typename]).map { |sym| "#{sym}=#{instance_variable_get("@#{sym}").inspect}" }
-        buf = "#<#{self.class.name}"
+        buf = "#<GraphQL::Client::QueryResult"
         buf << " " << @__typename if @__typename
         buf << " " << ivars.join(" ") if ivars.any?
         buf << ">"

data/lib/graphql/language/nodes/inject_selection_ext.rb

@@ -0,0 +1,44 @@
+require "graphql"
+require "graphql/language/nodes/selection_ext"
+
+module GraphQL
+  module Language
+    module Nodes
+      module Selections
+        def inject_selection(*selections)
+          other = self.dup
+          other.selections = selections + self.selections.map do |selection|
+            case selection
+            when Selections
+              selection.inject_selection(*selections)
+            else
+              selection
+            end
+          end
+          other
+        end
+      end
+
+      class Document < AbstractNode
+        def inject_selection(*args)
+          other = self.dup
+          other.definitions = self.definitions.map do |definition|
+            case definition
+            when Selections
+              definition.inject_selection(*args)
+            else
+              definition
+            end
+          end
+          other
+        end
+      end
+
+      class Field < AbstractNode
+        def inject_selection(*selections)
+          self.selections.any? ? super : self
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/nodes/query_result_class_ext.rb

@@ -0,0 +1,70 @@
+require "graphql"
+require "graphql/language/nodes/selection_ext"
+require "graphql/client/query_result"
+require "set"
+
+module GraphQL
+  module Language
+    module Nodes
+      module Selections
+        # Public: Get GraphQL::QueryResult class for result of query.
+        #
+        # Returns subclass of QueryResult or nil.
+        def query_result_class(**kargs)
+          GraphQL::Client::QueryResult.define(fields: selections_query_result_classes(**kargs))
+        end
+
+        def selection_query_result_classes(**kargs)
+          selections_query_result_classes(**kargs)
+        end
+
+        # Internal: Gather QueryResult classes for each selection.
+        #
+        # Returns a Hash[String => (QueryResult|nil)].
+        def selections_query_result_classes(shadow: Set.new, **kargs)
+          self.selections.inject({}) do |h, selection|
+            case selection
+            when Selection
+              if !shadow.include?(selection)
+                selection.selection_query_result_classes(shadow: shadow, **kargs).each do |name, klass|
+                  h[name] ? h[name] |= klass : h[name] = klass
+                end
+              end
+              h
+            else
+              raise TypeError, "expected selection to be of type Selection, but was #{selection.class}"
+            end
+          end
+        end
+      end
+
+      class Field < AbstractNode
+        # Public: Get GraphQL::QueryResult class for result of query.
+        #
+        # Returns subclass of QueryResult or nil.
+        def query_result_class(**kargs)
+          if self.selections.any?
+            super
+          else
+            nil
+          end
+        end
+
+        def selection_query_result_classes(**kargs)
+          name = self.alias || self.name
+          { name => query_result_class(**kargs) }
+        end
+      end
+
+      class FragmentSpread < AbstractNode
+        def selection_query_result_classes(fragments: {}, shadow: Set.new, **kargs)
+          unless fragment = fragments[name.to_sym]
+            raise ArgumentError, "missing fragment '#{name}'"
+          end
+          return {} if shadow.include?(fragment)
+          fragment.selection_query_result_classes(fragments: fragments, shadow: shadow, **kargs)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/nodes/replace_fragment_spread_ext.rb

@@ -0,0 +1,44 @@
+require "graphql"
+require "graphql/language/nodes/selection_ext"
+
+module GraphQL
+  module Language
+    module Nodes
+      module Selections
+        def replace_fragment_spread(fragments)
+          other = self.dup
+          other.selections = self.selections.map do |selection|
+            case selection
+            when FragmentSpread
+              if fragment = fragments[selection.name.to_sym]
+                InlineFragment.new(type: fragment.type, directives: fragment.directives, selections: fragment.selections)
+              else
+                selection
+              end
+            when Selections
+              selection.replace_fragment_spread(fragments)
+            else
+              selection
+            end
+          end
+          other
+        end
+      end
+
+      class Document < AbstractNode
+        def replace_fragment_spread(fragments)
+          other = self.dup
+          other.definitions = self.definitions.map do |definition|
+            case definition
+            when Selections
+              definition.replace_fragment_spread(fragments)
+            else
+              definition
+            end
+          end
+          other
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language/nodes/selection_ext.rb

@@ -0,0 +1,37 @@
+require "graphql"
+
+module GraphQL
+  module Language
+    module Nodes
+      # Public: Define shared trait for Nodes that have a "selections" collection.
+      module Selections
+      end
+
+      # Public: Define shared trait for Nodes that may be in a "selections" collection.
+      module Selection
+      end
+
+      class Field < AbstractNode
+        include Selection
+        include Selections
+      end
+
+      class FragmentDefinition < AbstractNode
+        include Selections
+      end
+
+      class FragmentSpread < AbstractNode
+        include Selection
+      end
+
+      class InlineFragment < AbstractNode
+        include Selection
+        include Selections
+      end
+
+      class OperationDefinition < AbstractNode
+        include Selections
+      end
+    end
+  end
+end

data/lib/graphql/language/nodes/validate_ext.rb

@@ -0,0 +1,45 @@
+require "graphql"
+
+module GraphQL
+  class ValidationError < GraphQL::ExecutionError
+  end
+
+  module Language
+    module Nodes
+      class Document < AbstractNode
+        def validate!(schema:, rules: StaticValidation::ALL_RULES)
+          validator = StaticValidation::Validator.new(schema: schema, rules: rules)
+          query = Query.new(schema, document: self)
+
+          validator.validate(query).fetch(:errors).each do |error|
+            raise ValidationError, error["message"]
+          end
+
+          nil
+        end
+      end
+
+      class FragmentDefinition < AbstractNode
+        def validate!(schema:, **kargs)
+          document = Document.new(definitions: [self])
+          rules = StaticValidation::ALL_RULES - [StaticValidation::FragmentsAreUsed]
+          document.validate!(schema: schema, rules: rules, **kargs)
+        end
+      end
+
+      class OperationDefinition < AbstractNode
+        def validate!(schema:, **kargs)
+          document = Document.new(definitions: [self])
+          document.validate!(schema: schema, **kargs)
+        end
+      end
+
+      class InlineFragment < AbstractNode
+        def validate!(schema:, **kargs)
+          fragment = FragmentDefinition.new(name: "FooFragment", type: self.type, directives: self.directives, selections: self.selections)
+          fragment.validate!(schema: schema, **kargs)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/node_query.rb

@@ -0,0 +1,19 @@
+require "graphql"
+require "graphql/language/nodes/deep_freeze_ext"
+
+module GraphQL
+  module Relay
+    NODE_QUERY = GraphQL.parse(<<-'GRAPHQL').definitions.first.deep_freeze
+      query($id: ID!) {
+        node(id: $id) {
+          ...NodeFragment
+        }
+      }
+    GRAPHQL
+
+    def self.NodeQuery(fragment)
+      fragment = GraphQL::Language::Nodes::FragmentDefinition.new(name: "NodeFragment", type: fragment.type, selections: fragment.selections)
+      GraphQL::Language::Nodes::Document.new(definitions: [NODE_QUERY, fragment])
+    end
+  end
+end

data/lib/graphql/schema/json_loader.rb

@@ -0,0 +1,101 @@
+require "graphql"
+require "json"
+
+module GraphQL
+  class Schema
+    module JSONLoader
+      def self.define_schema(json)
+        schema = JSON.load(json).fetch("data").fetch("__schema")
+        types = Schema::JSONLoader.define_types(schema)
+        # TODO: handle schema["mutationType"]
+        # TODO: handle schema["subscriptionType"]
+        query = types.fetch(schema.fetch("queryType").fetch("name"))
+        Schema.new(query: query, types: types.values)
+      end
+
+      def self.define_types(schema)
+        schema.fetch("types").inject({}) do |types, type|
+          type_kind, type_name = type.fetch("kind"), type.fetch("name")
+
+          if !type_name.start_with?("__")
+            case type_kind
+            when "INTERFACE"
+              types[type_name] = define_interface(types, type)
+            when "OBJECT"
+              types[type_name] = define_object(types, type)
+            when "SCALAR"
+              types[type_name] = define_scalar(types, type)
+            else
+              # TODO: handle other type kinds
+              fail NotImplementedError, type_kind + " not implemented"
+            end
+          end
+
+          types
+        end
+      end
+
+      def self.resolve_type(types, type)
+        case kind = type.fetch("kind")
+        when "INTERFACE"
+          types.fetch(type.fetch("name"))
+        when "LIST"
+          ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
+        when "NON_NULL"
+          NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
+        when "OBJECT"
+          types.fetch(type.fetch("name"))
+        when "SCALAR"
+          types.fetch(type.fetch("name"))
+        else
+          # TODO: handle other type kinds
+          fail NotImplementedError, kind + " not implemented"
+        end
+      end
+
+      def self.define_interface(types, type)
+        InterfaceType.define do
+          name type.fetch("name")
+        end
+      end
+
+      def self.define_object(types, type)
+        ObjectType.define do
+          name type.fetch("name")
+          description type["description"]
+
+          Array(type["fields"]).each do |field_data|
+            field field_data["name"] do
+              type JSONLoader.resolve_type(types, field_data["type"])
+              description field_data["description"]
+              field_data["args"].each do |arg|
+                argument arg["name"] do
+                  type JSONLoader.resolve_type(types, arg["type"])
+                  description arg["description"]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def self.define_scalar(types, type)
+        case name = type.fetch("name")
+        when "Int"
+          INT_TYPE
+        when "String"
+          STRING_TYPE
+        when "Float"
+          FLOAT_TYPE
+        when "Boolean"
+          BOOLEAN_TYPE
+        when "ID"
+          ID_TYPE
+        else
+          # TODO: handle other scalar names
+          fail NotImplementedError, name + " scalar not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema_load_json.rb

@@ -0,0 +1,10 @@
+require "graphql"
+require "graphql/schema/json_loader"
+
+module GraphQL
+  class Schema
+    def self.load_json(json)
+      Schema::JSONLoader.define_schema(json)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - GitHub
@@ -74,12 +74,20 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - lib/graphql/client.rb
-- lib/graphql/client/const_proxy.rb
+- lib/graphql/client/document.rb
+- lib/graphql/client/fragment.rb
+- lib/graphql/client/node.rb
+- lib/graphql/client/query.rb
 - lib/graphql/client/query_result.rb
-- lib/graphql/language/mutator.rb
 - lib/graphql/language/nodes/deep_freeze_ext.rb
-- lib/graphql/language/operation_slice.rb
-- lib/graphql/relay/parser.rb
+- lib/graphql/language/nodes/inject_selection_ext.rb
+- lib/graphql/language/nodes/query_result_class_ext.rb
+- lib/graphql/language/nodes/replace_fragment_spread_ext.rb
+- lib/graphql/language/nodes/selection_ext.rb
+- lib/graphql/language/nodes/validate_ext.rb
+- lib/graphql/relay/node_query.rb
+- lib/graphql/schema/json_loader.rb
+- lib/graphql/schema_load_json.rb
 homepage: 
 licenses:
 - MIT

data/lib/graphql/client/const_proxy.rb

@@ -1,29 +0,0 @@
-module GraphQL
-  class Client
-    # Internal: Hack to track the constant name an object is assigned to.
-    #
-    #   FooConstant = ConstProxy.new { |name|
-    #     name # "FooConstant"
-    #   }
-    #
-    module ConstProxy
-      def self.new(&initializer)
-        raise ArgumentError, "initializer required" unless block_given?
-
-        Module.new do
-          extend ConstProxy
-          @initializer = initializer
-        end
-      end
-
-      def name
-        super || raise(RuntimeError, "expected object to be assigned to a constant")
-      end
-
-      def method_missing(*args, &block)
-        @target ||= @initializer.call(self.name)
-        @target.send(*args, &block)
-      end
-    end
-  end
-end

data/lib/graphql/language/mutator.rb

@@ -1,45 +0,0 @@
-require "graphql"
-require "set"
-
-module GraphQL
-  module Language
-    class Mutator
-      def initialize(document)
-        @document = document
-      end
-
-      def rename_definitions(definitions)
-        rename_node = -> (node, parent) {
-          node.name = definitions.fetch(node.name, node.name)
-        }
-
-        visitor = Visitor.new(@document)
-        visitor[Nodes::FragmentDefinition].leave << rename_node
-        visitor[Nodes::OperationDefinition].leave << rename_node
-        visitor[Nodes::FragmentSpread].leave << rename_node
-        visitor.visit
-
-        nil
-      end
-
-      def prepend_selection(selection)
-        on_selections = -> (node, parent) {
-          return if !node.selections.any?
-          # TODO: Simplify if AbstractNode#eql? is implemented
-          existing_selections = Set.new(node.selections.map { |s| s.respond_to?(:name) ? s.name : nil }.compact)
-          selections_to_prepend = [selection].reject { |s| existing_selections.include?(s.name) }
-          node.selections = selections_to_prepend + node.selections
-        }
-
-        visitor = Visitor.new(@document)
-        visitor[Nodes::Field].leave << on_selections
-        visitor[Nodes::FragmentDefinition].leave << on_selections
-        visitor[Nodes::InlineFragment].leave << on_selections
-        visitor[Nodes::OperationDefinition].leave << on_selections
-        visitor.visit
-
-        nil
-      end
-    end
-  end
-end

data/lib/graphql/language/operation_slice.rb

@@ -1,31 +0,0 @@
-require "graphql"
-
-module GraphQL
-  module Language
-    module OperationSlice
-      # Public: Return's minimal document to represent operation.
-      #
-      # Find's target operation and any fragment dependencies and returns a
-      # new document with just those definitions.
-      #
-      # document - The Nodes::Document to find definitions.
-      # operation_name - The String name of Nodes::OperationDefinition
-      #
-      # Returns new Nodes::Document.
-      def self.slice(document, operation_name)
-        definitions = []
-        definitions << document.definitions.find { |d| d.name == operation_name }
-
-        visitor = Visitor.new(document)
-        visitor[Nodes::FragmentSpread] << -> (node, parent) {
-          if fragment = document.definitions.find { |d| d.name == node.name }
-            definitions << fragment
-          end
-        }
-        visitor.visit
-
-        Nodes::Document.new(definitions: definitions.uniq)
-      end
-    end
-  end
-end

data/lib/graphql/relay/parser.rb

@@ -1,27 +0,0 @@
-require "graphql"
-
-module GraphQL
-  module Relay
-    module Parser
-      ANONYMOUS_SENTINEL = "__anonymous__".freeze
-
-      # Public: Extended GraphQL.parse that supports Relay style anonymous
-      # fragments.
-      #
-      # TODO: See about getting support for this upstreamed to the graphql-ruby
-      # gem.
-      #
-      # str - A GraphQL String
-      #
-      # Returns a GraphQL::Language::Nodes::Document.
-      def self.parse(str)
-        str = str.sub(/fragment on /, "fragment #{ANONYMOUS_SENTINEL} on ")
-        document = GraphQL.parse(str)
-        document.definitions.each do |node|
-          node.name = nil if node.name == ANONYMOUS_SENTINEL
-        end
-        document
-      end
-    end
-  end
-end