graphlyte 0.3.2 → 1.0.0

data/lib/graphlyte/syntax.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+
+require_relative './errors'
+require_relative './data'
+require_relative './refinements/syntax_refinements'
+
+module Graphlyte
+  module Syntax
+    # An operation represents a top-level executable definition of
+    # a query, mutation or a subscription.
+    # See: https://spec.graphql.org/October2021/#sec-Language.Operations
+    class Operation < Graphlyte::Data
+      attr_reader :type
+      attr_accessor :name, :variables, :directives, :selection
+
+      def initialize(type: nil, **args)
+        super(**args)
+        self.type = type if type
+      end
+
+      def executable?
+        true
+      end
+
+      def valid?
+        !selection.empty? && valid_type?
+      end
+
+      def valid_type?
+        %i[query mutation subscription].include?(type)
+      end
+
+      def type=(value)
+        @type = value
+        return if valid_type?
+
+        raise IllegalValue,
+              "Illegal value: #{value.inspect}. Expected query, mutation or subscription"
+      end
+    end
+
+    # An argument to a Field
+    # See: https://spec.graphql.org/October2021/#sec-Language.Arguments
+    class Argument < Graphlyte::Data
+      attr_accessor :name, :value
+
+      def initialize(name = nil, value = nil, **kwargs)
+        super(**kwargs)
+        @name = name if name
+        @value = value if value
+      end
+    end
+
+    Directive = Struct.new(:name, :arguments)
+
+    # Clases that have fragment names may include this module
+    module HasFragmentName
+      def self.included(mod)
+        mod.attr_reader :name
+      end
+
+      def name=(value)
+        raise IllegalValue, 'Not a legal fragment name' if value == 'on'
+
+        @name = value
+      end
+    end
+
+    # A discrete piece of information in the Graph
+    # See: https://spec.graphql.org/October2021/#sec-Language.Fields
+    class Field < Graphlyte::Data
+      attr_accessor :as, :name, :arguments, :directives, :selection
+      # type is special: it is not part of the serialized Query, but
+      # inferred from the schema. See: editors/annotate_types.rb
+      attr_accessor :type
+
+      def initialize(**kwargs)
+        super
+        @arguments ||= []
+        @directives ||= []
+        @selection ||= []
+      end
+
+      def simple?
+        as.nil? && arguments.empty? && directives.empty? && selection.empty?
+      end
+    end
+
+    # A reference to the use of a Fragment
+    # See: https://spec.graphql.org/October2021/#FragmentSpread
+    class FragmentSpread < Graphlyte::Data
+      include HasFragmentName
+
+      attr_accessor :directives
+
+      def simple?
+        false
+      end
+    end
+
+    InlineFragment = Struct.new(:type_name, :directives, :selection) do
+      def simple?
+        false
+      end
+    end
+
+    # A definition of a re-usable chunk of an operation
+    # See: https://spec.graphql.org/October2021/#sec-Language.Fragments
+    class Fragment < Graphlyte::Data
+      include HasFragmentName
+
+      attr_accessor :type_name, :directives, :selection
+
+      def initialize(**kwargs)
+        super
+        @refers_to = []
+      end
+
+      def inline
+        InlineFragment.new(type_name, directives, selection)
+      end
+
+      def refers_to(fragment)
+        @refers_to << fragment
+      end
+
+      def required_fragments
+        [self] + @refers_to
+      end
+
+      def executable?
+        true
+      end
+    end
+
+    Literal = Struct.new(:value, :type, :to_s) # rubocop:disable Lint/StructNewOverride
+    NULL = Literal.new(nil, :NULL, 'null').freeze
+    TRUE = Literal.new(true, :BOOL, 'true').freeze
+    FALSE = Literal.new(false, :BOOL, 'false').freeze
+
+    VariableDefinition = Struct.new(:variable, :type, :default_value, :directives, keyword_init: true)
+
+    # A use of a variable in an operation or fragment
+    # See: https://spec.graphql.org/October2021/#Variable
+    class VariableReference < Graphlyte::Data
+      attr_accessor :variable, :inferred_type
+
+      def initialize(variable = nil, inferred_type = nil, **kwargs)
+        super(**kwargs)
+        @variable ||= variable
+        @inferred_type ||= inferred_type
+      end
+
+      def to_definition
+        VariableDefinition.new(variable: variable, type: inferred_type)
+      end
+
+      private
+
+      def state
+        @variable
+      end
+    end
+
+    # A reference to a type, possibly containing other types.
+    # See: https://spec.graphql.org/October2021/#sec-Type-References
+    class Type < Graphlyte::Data
+      attr_accessor :inner, :is_list, :non_null, :non_null_list
+
+      def initialize(name = nil, **kwargs)
+        super(**kwargs)
+        @inner ||= name
+        @is_list ||= false
+        @non_null ||= false
+        @non_null_list ||= false
+      end
+
+      # Used during value->type inference
+      # always non-null, because we have a value.
+      def self.list_of(inner)
+        t = new(inner)
+        t.is_list = true
+        t.non_null = true
+        t
+      end
+
+      def to_s
+        str = inner.to_s
+        str = "#{str}!" if non_null
+        str = "[#{str}]" if is_list
+        str += '!' if non_null_list
+
+        str
+      end
+
+      def unpack
+        return inner if inner.is_a?(String)
+
+        inner.unpack
+      end
+
+      def self.from_type_ref(type_ref)
+        raise ArgumentError, 'type_ref cannot be nil' if type_ref.nil?
+
+        inner = from_type_ref(type_ref.of_type) if type_ref.of_type
+
+        case type_ref.kind
+        when :NON_NULL
+          non_null(inner)
+        when :LIST
+          list_type(inner)
+        when :SCALAR, :OBJECT, :ENUM
+          raise ArgumentError, "#{type_ref.kind} cannot have inner type" if inner
+
+          new(inner: type_ref.name)
+        else
+          raise ArgumentError, "Unexpected kind: #{type_ref.kind.inspect}"
+        end
+      end
+
+      def self.list_type(inner)
+        raise ArgumentError, 'List types must have inner type' unless inner
+
+        new(is_list: true, inner: inner)
+      end
+
+      def self.non_null(inner)
+        raise ArgumentError, 'Non null types must have inner type' unless inner
+
+        type = new(non_null: true, inner: inner)
+
+        if inner.respond_to?(:is_list) && inner.is_list
+          type.is_list = true
+          type.inner = inner.inner
+        end
+
+        type
+      end
+    end
+
+    # A CONST input value
+    # See: https://spec.graphql.org/October2021/#sec-Input-Values
+    class Value < Graphlyte::Data
+      using Refinements::SyntaxRefinements
+
+      attr_accessor :value, :type
+
+      def initialize(value = nil, type = nil, **kwargs)
+        super(**kwargs)
+        @value = value if value
+        @type = type if type
+        @type ||= value&.type
+      end
+
+      def self.from_name(name)
+        case name
+        when 'true'
+          true.to_input_value
+        when 'false'
+          false.to_input_value
+        when 'null'
+          nil.to_input_value
+        else
+          name.to_sym.to_input_value
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} @type=#{type} @value=#{value.inspect}>"
+      end
+      alias to_s inspect
+
+      def eql?(other)
+        return true if super
+        return true if numeric_eql?(other)
+
+        false
+      end
+
+      def numeric_eql?(other)
+        return false unless number?
+        return false unless other&.number?
+
+        if floating? || other.floating?
+          (value.to_f - other.value.to_f) < Float::EPSILON
+        else
+          value.to_i == other.value.to_i
+        end
+      end
+
+      def floating?
+        return false unless number?
+        return true if value.is_a?(Float)
+        return true if value.is_a?(NumericLiteral) && value.floating?
+
+        false
+      end
+
+      def number?
+        type == :NUMBER
+      end
+
+      def self.from_ruby(object)
+        object.to_input_value
+      rescue NoMethodError
+        raise IllegalValue, object
+      end
+    end
+
+    # A representation of a GraphQL literal, preserving the text components
+    #
+    # Note: NumericLiterals are immutable.
+    class NumericLiteral < Graphlyte::Data
+      attr_reader :integer_part, :fractional_part, :exponent_part, :negated
+
+      def initialize(**kwargs)
+        super
+        @negated ||= false
+
+        raise ArgumentError, 'integer_part is required' unless @integer_part
+
+        freeze
+      end
+
+      def floating?
+        !!@fractional_part || !!@exponent_part
+      end
+
+      def to_s
+        s = "#{negated ? '-' : ''}#{integer_part}"
+        return s unless floating?
+
+        s << ".#{fractional_part}" if fractional_part
+        s << "e#{exponent_part.first}#{exponent_part.last}" if @exponent_part
+
+        s
+      end
+
+      def to_i
+        unnegate(negated, integer_part.to_i)
+      end
+
+      def to_f
+        n = to_i.to_f
+        n += fractional_value if fractional_part
+        n *= exponent_value if exponent_part
+
+        n
+      end
+
+      private
+
+      attr_writer :integer_part, :fractional_part, :exponent_part, :negated
+
+      def exponent_value
+        10**unnegate(exponent_part.first, exponent_part.last.to_i)
+      end
+
+      def fractional_value
+        fp = unnegate(negated, fractional_part.to_i.to_f)
+        fp / (10**fractional_part.length)
+      end
+
+      def unnegate(negated, value)
+        value * (negated ? -1 : 1)
+      end
+    end
+  end
+end

data/lib/graphlyte.rb

@@ -1,54 +1,36 @@
+# frozen_string_literal: true
+
+require 'forwardable'
 require 'json'
-require_relative "./graphlyte/fieldset"
-require_relative "./graphlyte/query"
-require_relative "./graphlyte/fragment"
-require_relative 'graphlyte/inline_fragment'
-require_relative "./graphlyte/schema_query"
-require_relative "./graphlyte/types"
-require_relative "./graphlyte/schema/parser"
 
+require_relative './graphlyte/syntax'
+require_relative './graphlyte/schema'
+require_relative './graphlyte/lexer'
+require_relative './graphlyte/parser'
+require_relative './graphlyte/editor'
+require_relative './graphlyte/serializer'
+require_relative './graphlyte/selector'
+require_relative './graphlyte/selection_builder'
+require_relative './graphlyte/dsl'
+require_relative './graphlyte/schema_query'
+
+# A GraphQL parsing, introspection, construction and manipulation library
 module Graphlyte
   extend SchemaQuery
+  extend SingleForwardable
 
-  TYPES = Types.new
-
-  def self.parse(gql)
-    Graphlyte::Schema::Parser.parse(gql)
-  end
-
-  def self.query(name = nil, &block)
-    Query.new(name, :query, builder: build(&block))
-  end
-
-  def self.mutation(name = nil, &block)
-    Query.new(name, :mutation, builder: build(&block))
-  end
-
-  def self.custom(name, type, &block)
-    Query.new(name, type.to_sym, builder: build(&block))
-  end
-
-  def self.inline_fragment(model_name, &block)
-    InlineFragment.new(model_name, builder: build(&block))
-  end
+  NO_SCHEMA_DSL = Graphlyte::DSL.new
 
-  def self.inline_directive(directive, **hargs, &block)
-    InlineFragment.from_directive(directive, **hargs, builder: build(&block) )
-  end
+  def_delegators 'Graphlyte::NO_SCHEMA_DSL', :query, :mutation, :var, :fragment
 
-  def self.fragment(fragment_name, model_name, &block)
-    Fragment.new(fragment_name, model_name, builder: build(&block))
-  end
+  def self.parse(gql)
+    ts = Graphlyte::Lexer.lex(gql)
+    parser = Graphlyte::Parser.new(tokens: ts)
 
-  def self.fieldset(model_name=nil, &block)
-    Fieldset.new(model_name, builder: build(&block))
+    parser.query
   end
 
-  private
-
-  def self.build(&block)
-    builder = Builder.new
-    builder.>.instance_eval(&block)
-    builder
+  def self.dsl(schema)
+    DSL.new(schema)
   end
 end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Sean Gregory
+- Alex Kalderimis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-28 00:00:00.000000000 Z
+date: 2022-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,33 +39,101 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-cobertura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: super_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: craft graphql queries with ruby
-email: sean.christopher.gregory@gmail.com
+email: alex.kalderimis@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/graphlyte.rb
-- lib/graphlyte/arguments/set.rb
-- lib/graphlyte/arguments/value.rb
-- lib/graphlyte/arguments/value_literal.rb
-- lib/graphlyte/builder.rb
-- lib/graphlyte/directive.rb
-- lib/graphlyte/field.rb
-- lib/graphlyte/fieldset.rb
-- lib/graphlyte/fragment.rb
-- lib/graphlyte/inline_fragment.rb
-- lib/graphlyte/query.rb
+- lib/graphlyte/data.rb
+- lib/graphlyte/document.rb
+- lib/graphlyte/dsl.rb
+- lib/graphlyte/editor.rb
+- lib/graphlyte/editors/annotate_types.rb
+- lib/graphlyte/editors/canonicalize.rb
+- lib/graphlyte/editors/collect_variable_references.rb
+- lib/graphlyte/editors/infer_signature.rb
+- lib/graphlyte/editors/inline_fragments.rb
+- lib/graphlyte/editors/remove_unneeded_spreads.rb
+- lib/graphlyte/editors/select_operation.rb
+- lib/graphlyte/editors/with_variables.rb
+- lib/graphlyte/errors.rb
+- lib/graphlyte/lexer.rb
+- lib/graphlyte/lexing/location.rb
+- lib/graphlyte/lexing/token.rb
+- lib/graphlyte/parser.rb
+- lib/graphlyte/parsing/backtracking_parser.rb
 - lib/graphlyte/refinements/string_refinement.rb
-- lib/graphlyte/schema/parser.rb
-- lib/graphlyte/schema/types/base.rb
+- lib/graphlyte/refinements/syntax_refinements.rb
+- lib/graphlyte/schema.rb
 - lib/graphlyte/schema_query.rb
-- lib/graphlyte/types.rb
+- lib/graphlyte/selection_builder.rb
+- lib/graphlyte/selector.rb
+- lib/graphlyte/serializer.rb
+- lib/graphlyte/syntax.rb
 homepage: https://rubygems.org/gems/graphlyte
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://gitlab.com/seanchristophergregory/graphlyte
+  source_code_uri: https://gitlab.com/skinnyjames/graphlyte
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -73,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/graphlyte/arguments/set.rb

@@ -1,94 +0,0 @@
-require_relative "./value"
-require_relative "./../refinements/string_refinement"
-module Graphlyte
-  module Arguments
-    class Set
-      using Refinements::StringRefinement
-
-      attr_reader :values
-
-      def initialize(data)
-        raise ArgumentError, "input #{data} must be a hash" unless data.nil? || data.is_a?(Hash)
-        @values = expand_arguments(data) unless data.nil?
-      end
-
-      def resolve_lazy_special_args(parser_special_args)
-        @values&.each do |key, value|
-          if value.is_a?(Set)
-            value.resolve_lazy_special_args(parser_special_args) if value.is_a?(Set)
-          elsif value.is_a?(Array)
-            value.each do |it|
-              it.refresh(parser_special_args) if it.is_a?(Value)
-              it.resolve_lazy_special_args(parser_special_args) if it.is_a?(Set)
-            end
-          else
-            value.refresh(parser_special_args)
-          end
-          [key, value]
-        end.to_h
-      end
-
-      def extract_variables(values=@values, variables=[])
-        values&.each do |key, value|
-          if value.is_a?(Set)
-            variables.concat extract_variables(value.values)
-          elsif value.is_a?(Array)
-          elsif value.symbol?
-            variables << value
-          elsif value.formal?
-            variables << value
-          end
-        end
-        variables
-      end
-
-      def to_h(raw = false)
-        return {} unless values && !values.empty?
-        values.inject({}) do |memo, (k, v)|
-          if v.is_a?(Array)
-            memo[k.to_s.to_camel_case] = v.map { |value| value.to_s(raw) }
-          elsif v.is_a?(Set)
-            memo[k.to_s.to_camel_case] = v.to_h
-          else
-            memo[k.to_s.to_camel_case] = v.to_s(raw)
-          end
-          memo
-        end
-      end
-      
-      def to_s(inner = false)
-        return "" unless values && !values.empty?
-        arr = stringify_arguments
-        return arr.join(", ") if inner
-        "(#{arr.join(", ")})"
-      end
-
-      private 
-
-      def stringify_arguments
-        values.map do |k,v|
-          if v.is_a?(Array)
-            "#{k.to_s.to_camel_case}: [#{v.map(&:to_s).join(", ")}]"
-          elsif v.is_a?(Set)
-            "#{k.to_s.to_camel_case}: { #{v.to_s(true)} }"
-          else
-            "#{k.to_s.to_camel_case}: #{v.to_s}"
-          end
-        end
-      end
-
-      def expand_arguments(data)
-        data.transform_values do |value|
-          case value
-          when Array
-            value.map { |item| Value.from(item) }
-          when Hash
-            Set.new(value)
-          else
-            Value.from(value)
-          end
-        end
-      end
-    end
-  end
-end