graphlyte 0.3.2 → 1.0.0

data/lib/graphlyte/selection_builder.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative './syntax'
+require_relative './refinements/string_refinement'
+
+module Graphlyte
+  # Helper to build arguments for a field selection.
+  class ArgumentBuilder
+    using Graphlyte::Refinements::StringRefinement
+
+    def initialize(document)
+      @document = document
+    end
+
+    def build(arguments)
+      return [] unless arguments.any?
+
+      arguments.to_a.map do |(k, v)|
+        value = case v
+                when Syntax::Value
+                  v # built via Graphlyte.enum for example
+                when SelectionBuilder::Variable
+                  @document.declare(v)
+                when Symbol
+                  Syntax::VariableReference.new(v.name.camelize)
+                else
+                  Syntax::Value.from_ruby(v)
+                end
+
+        Syntax::Argument.new(k.to_s.camelize, value)
+      end
+    end
+  end
+
+  # The return value from `select!`. Allows further modifications (aliasing,
+  # directives) to the field.
+  class WithField
+    def initialize(field, builder)
+      @field = field
+      @builder = builder
+    end
+
+    def alias(name, &block)
+      @field.as = name
+
+      @field.selection += @builder.build!(&block) if block_given?
+
+      self
+    end
+
+    def method_missing(name, *_args, **kwargs, &block)
+      directive = Syntax::Directive.new(name.to_s)
+
+      directive.arguments = @builder.argument_builder!.build(kwargs) if kwargs.any?
+
+      @field.selection += @builder.build!(&block) if block_given?
+
+      @field.directives << directive
+
+      self
+    end
+
+    def respond_to_missing?(*)
+      true
+    end
+  end
+
+  # Main construct used to build selection sets, uses `method_missing` to
+  # select fields.
+  #
+  # Note: instance methods are either symbolic or end in bangs to avoid
+  # shadowing legal field names.
+  #
+  # Usage:
+  #
+  #   some_fields = %w[all these fields]
+  #   selection = SelectionBuilder.build(document) do
+  #     foo                             # basic field
+  #     bar(baz: 1) { x; y; z}          # field with sub-selection
+  #     some_fields.each { self << _1 } # Adding fields dynamically
+  #   end
+  #
+  # You should probably never need to call this directly - it is used to
+  # implement the DSL class.
+  class SelectionBuilder
+    using Graphlyte::Refinements::StringRefinement
+
+    # Variables should not be re-used between queries
+    Variable = Struct.new(:type, :name, keyword_init: true)
+
+    def self.build(document, &block)
+      return [] unless block_given?
+
+      new(document).build!(&block)
+    end
+
+    def initialize(document)
+      @document = document
+    end
+
+    def build!
+      old = @selection
+      curr = []
+      return curr unless block_given?
+
+      @selection = curr
+
+      yield self
+
+      curr
+    ensure
+      @selection = old
+    end
+
+    def on!(type_name, &block)
+      frag = Graphlyte::Syntax::InlineFragment.new
+      frag.type_name = type_name
+      frag.selection = build!(&block)
+
+      select! frag
+    end
+
+    # Selected can be:
+    #
+    # - a string or symbol (field name)
+    # - a Graphlyte::Syntax::{Fragment,Field,InlineFragment}
+    # - a SelectionBuilder::Variable (constructed with `DSL#var`).
+    #
+    # Use of this method (or `select!`) is necessary to add fields
+    # that shadow core method or construct names (e.g. `if`, `open`, `else`,
+    # `class` and so on).
+    def <<(selected)
+      select!(selected)
+    end
+
+    def select!(selected, *args, **kwargs, &block)
+      case selected
+      when Graphlyte::Syntax::Fragment
+        @document.add_fragments(selected.required_fragments)
+        @selection << Graphlyte::Syntax::FragmentSpread.new(name: selected.name)
+      when Graphlyte::Syntax::InlineFragment, Graphlyte::Syntax::Field
+        @selection << selected
+      else
+        field = new_field!(selected.to_s, args)
+        field.arguments = argument_builder!.build(kwargs)
+        field.selection += self.class.build(@document, &block)
+
+        WithField.new(field, self)
+      end
+    end
+
+    def argument_builder!
+      @argument_builder ||= ArgumentBuilder.new(@document)
+    end
+
+    private
+
+    def new_field!(name, args)
+      field = Syntax::Field.new(name: name)
+      @selection << field
+
+      args.each do |arg|
+        case arg
+        when Symbol
+          field.directives << Syntax::Directive.new(arg.to_s)
+        when WithField
+          raise ArgumentError, 'Reference error' # caused by typos usually.
+        else
+          field.selection += self.class.build(@document) { _1.select! arg }
+        end
+      end
+
+      field
+    end
+
+    def method_missing(name, *args, **kwargs, &block)
+      if name.to_s.end_with?('=') && args.length == 1 && args[0].is_a?(WithField)
+        aka = name.to_s.chomp('=')
+        args[0].alias(aka)
+      else
+        select!(name.to_s.camelize, *args, **kwargs.transform_keys(&:camelize), &block)
+      end
+    end
+
+    def respond_to_missing?(*)
+      true
+    end
+  end
+end

data/lib/graphlyte/selector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative './syntax'
+require_relative './editor'
+
+module Graphlyte
+  # A tool for simple editing of GraphQL queries using a path-based API
+  #
+  # Usage:
+  #
+  #   editor = Selector.new
+  #   editor.at('project.pipelines.nodes.status', &:remove)
+  #   editor.at('project.pipelines.nodes') do |node|
+  #     node.append do
+  #       downstream do
+  #         nodes { active }
+  #       end
+  #     end
+  #
+  #   editor.edit(doc)
+  #
+  class Selector
+    def initialize
+      @actions = {}
+    end
+
+    def at(path, &block)
+      raise ArgumentError 'block not given' unless block_given?
+
+      @actions[path] = block
+
+      self
+    end
+
+    def edit(doc)
+      editor = Editor.new.on_field do |field, action|
+        edit_field(field, action)
+      end
+
+      editor.edit(doc)
+
+      doc
+    end
+
+    def edit_field(field, action)
+      key = action.path.map { _1.name if _1.is_a?(Syntax::Field) }.compact.join('.')
+      block = @actions[key]
+
+      block&.call(SelectAction.new(field, action))
+    end
+
+    # Each block defined with `at` receives as its only argument a
+    # `SelectAction`. This object exposes method allowing the caller
+    # to modify the query.
+    class SelectAction
+      def initialize(field, action)
+        @field = field
+        @action = action
+      end
+
+      # Remove the current node.
+      def remove
+        @action.delete
+      end
+
+      # Construct a new selection using the block, and append it to the
+      # current field selection.
+      def append(&block)
+        selection = SelectionBuilder.build(@action.document, &block)
+
+        @field.selection += selection
+      end
+    end
+  end
+end

data/lib/graphlyte/serializer.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative './syntax'
+
+module Graphlyte
+  # Logic for writing a GraphQL document to a string
+  class Serializer
+    # Type directed serialization:
+    module Refinements
+      refine Syntax::VariableReference do
+        def serialize(buff)
+          buff << "$#{variable}"
+        end
+      end
+
+      refine Syntax::Argument do
+        def serialize(buff)
+          buff << "#{name}: "
+          value.serialize(buff)
+        end
+      end
+
+      refine Syntax::VariableDefinition do
+        def serialize(buff)
+          buff << "$#{variable}: #{type}"
+          if default_value
+            buff << ' = '
+            default_value.serialize(buff)
+          end
+          buff.dump_directives(self)
+        end
+      end
+
+      refine Syntax::Directive do
+        def serialize(buff)
+          buff << ' @' << name
+          buff.dump_arguments(self)
+        end
+      end
+
+      refine Syntax::Field do
+        def serialize(buff)
+          buff << "#{as}: " if as
+          buff << name
+          buff.dump_arguments(self)
+          buff.dump_directives(self)
+          buff.dump_selection(self)
+        end
+      end
+
+      refine Syntax::FragmentSpread do
+        def serialize(buff)
+          buff << '...' << name
+          buff.dump_directives(self)
+        end
+      end
+
+      refine Syntax::InlineFragment do
+        def serialize(buff)
+          buff << '... on ' << type_name
+          buff.dump_directives(self)
+          buff.dump_selection(self)
+        end
+      end
+
+      refine Syntax::Operation do
+        def serialize(buff)
+          buff << type
+          buff << " #{name}" if name
+          buff.comma_separated(variables)
+          buff.dump_directives(self)
+          buff.dump_selection(self)
+        end
+      end
+
+      refine Syntax::Fragment do
+        def serialize(buff)
+          buff << 'fragment ' << name << ' on ' << type_name
+          buff.dump_directives(self)
+          buff.dump_selection(self)
+        end
+      end
+
+      refine Syntax::Value do
+        def serialize(buff)
+          buff << case value
+                  when String
+                    # TODO: handle block strings?
+                    "\"#{value.gsub(/"/, '\"').gsub("\n", '\n').gsub("\t", '\t')}\""
+                  else
+                    value
+                  end
+        end
+      end
+
+      refine Array do
+        def serialize(buff)
+          # TODO: handle layout of large arrays nicely
+          buff << '['
+          each_with_index do |v, i|
+            buff << (', ' * [i, 1].min)
+            v.serialize(buff)
+          end
+          buff << ']'
+        end
+      end
+
+      refine Hash do
+        def serialize(buff)
+          buff << '{'
+          each.each_with_index do |(k, v), i|
+            buff << (', ' * [i, 1].min)
+            buff << k
+            buff << ': '
+            v.serialize(buff)
+          end
+          buff << '}'
+        end
+      end
+    end
+
+    using Refinements
+
+    Unsupported = Class.new(ArgumentError)
+    SPACE = ' '
+    STEP = 2
+    NEWLINE = "\n"
+
+    attr_reader :buff, :indent
+    attr_accessor :line_length, :max_fields_per_line
+
+    def initialize(buff = [])
+      @buff = buff
+      @line_length = 100
+      @max_fields_per_line = 5
+      @indent = 0
+    end
+
+    def <<(chunk)
+      @buff << chunk.to_s
+      self
+    end
+
+    def dump_definitions(definitions)
+      return unless definitions&.any?
+
+      definitions.each_with_index do |dfn, i|
+        buff << NEWLINE << NEWLINE if i.positive?
+        dfn.serialize(self)
+      rescue NoMethodError
+        raise Unsupported, dfn.class
+      end
+    end
+
+    def dump_selection(node)
+      i = @indent
+      selection = node.selection
+      return unless selection&.any?
+
+      @indent += STEP
+
+      buff << SPACE << '{'
+
+      if simple?(selection)
+        dump_simple_selection(selection)
+      else
+        dump_indented_selection(selection)
+      end
+
+      buff << '}'
+    ensure
+      @indent = i
+    end
+
+    def next_line
+      buff << NEWLINE << (SPACE * indent)
+    end
+
+    def dump_indented_selection(selection)
+      selection.each do |selected|
+        next_line
+
+        selected.serialize(self)
+      end
+
+      buff << NEWLINE << (SPACE * (indent - STEP))
+    end
+
+    def simple?(selection)
+      selection.length < max_fields_per_line &&
+        selection.all?(&:simple?) &&
+        (selection.sum { _1.name.length } + selection.length + indent) < line_length
+    end
+
+    def dump_simple_selection(selection)
+      buff << SPACE
+      selection.each do |selected|
+        selected.serialize(self)
+        buff << SPACE
+      end
+    end
+
+    def dump_directives(node)
+      node.directives&.each { _1.serialize(self) }
+    end
+
+    def comma_separated(collection)
+      return unless collection
+      return if collection.empty?
+
+      buff << '('
+      collection.each_with_index do |elem, i|
+        buff << (', ' * [i, 1].min)
+        elem.serialize(self)
+      end
+      buff << ')'
+    end
+
+    def dump_arguments(node)
+      comma_separated(node.arguments)
+    end
+  end
+end