graphql-client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c235ea2f0b7616533466fbc80031bf4d8d5a7ee
+  data.tar.gz: fc4192d111b17dc3cdf5e28a21e70818e2534695
+SHA512:
+  metadata.gz: d21e6ae9e95bc4ce084d566d49d67ed08e7863aab08df6c35099714dee0e2bab0fa6ea581b5139a4cbed08306510b3278c020c4a5b57d7658ebb6d6a560445d7
+  data.tar.gz: d5ee1964fd2c9f01e0f60b4c99166a27eb8201928a10000f59b70414d84385abaa06600ad1d494399287db46a01cc6a771b29fd61012e3a86332ea92cdb94a42

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 GitHub, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/graphql/client.rb

@@ -0,0 +1,14 @@
+require "graphql"
+require "graphql/client/document"
+require "graphql/client/fragment"
+require "graphql/client/node"
+require "graphql/client/query_result"
+require "graphql/client/query"
+
+module GraphQL
+  module Client
+    class << self
+      attr_accessor :schema
+    end
+  end
+end

data/lib/graphql/client/document.rb

@@ -0,0 +1,47 @@
+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.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

@@ -0,0 +1,102 @@
+require "graphql"
+require "active_support/inflector"
+
+module GraphQL
+  module Client
+    class QueryResult
+      def self.fields
+        @fields
+      end
+
+      def self.define(fields: {})
+        Class.new(self) do
+          @fields = {}
+
+          fields.each do |field, type|
+            @fields[field.to_sym] = type
+
+            send :attr_reader, field
+
+            # Convert GraphQL camelcase to snake case: commitComments -> commit_comments
+            field_alias = ActiveSupport::Inflector.underscore(field)
+            if field != field_alias
+              send :alias_method, field_alias, field
+            end
+
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def #{field_alias}?
+                #{field_alias} ? true : false
+              end
+            RUBY
+          end
+
+          assigns = fields.map do |field, type|
+            if type
+              <<-RUBY
+                @#{field} = self.class.fields[:#{field}].cast(@data["#{field}"])
+              RUBY
+            else
+              <<-RUBY
+                @#{field} = @data["#{field}"]
+              RUBY
+            end
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def initialize(data)
+              @data = data
+              #{assigns.join("\n")}
+              freeze
+            end
+          RUBY
+        end
+      end
+
+      def self.inspect
+        "#<GraphQL::Client::QueryResult fields=#{@fields.keys.inspect}>"
+      end
+
+      def self.cast(obj)
+        case obj
+        when Hash
+          new(obj)
+        when QueryResult
+          cast(obj.to_h)
+        when Array
+          obj.map { |e| cast(e) }
+        when NilClass
+          nil
+        else
+          raise TypeError, "#{obj.class}"
+        end
+      end
+
+      def self.new(obj)
+        case obj
+        when Hash
+          super
+        else
+          cast(obj)
+        end
+      end
+
+      attr_reader :data
+      alias_method :to_h, :data
+
+      def inspect
+        ivars = (self.class.fields.keys - [:__typename]).map { |sym| "#{sym}=#{instance_variable_get("@#{sym}").inspect}" }
+        buf = "#<GraphQL::Client::QueryResult"
+        buf << " " << @__typename if @__typename
+        buf << " " << ivars.join(" ") if ivars.any?
+        buf << ">"
+        buf
+      end
+
+      def method_missing(*args)
+        super
+      rescue NoMethodError => e
+        raise NoMethodError, "undefined method `#{e.name}' for #{inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "graphql"
+
+module GraphQL
+  module Language
+    module Nodes
+      class AbstractNode
+        # Public: Freeze entire Node tree
+        #
+        # Returns self Node.
+        def deep_freeze
+          self.class.child_attributes.each do |attr_name|
+            public_send(attr_name).freeze.each do |node|
+              node.deep_freeze
+            end
+          end
+          freeze
+        end
+      end
+    end
+  end
+end

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,69 @@
+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)
+                {}
+              else
+                h.merge!(selection.selection_query_result_classes(shadow: shadow, **kargs))
+              end
+            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

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: graphql-client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- GitHub
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/graphql/client.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/nodes/deep_freeze_ext.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
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: "???"
+test_files: []
+has_rdoc: