graphlyte 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ee4eed2122126ce2d651f0f63210598a48a9fb6a6919a4a20066e932fccdab3
-  data.tar.gz: 7d74b8dc7a8c46e949a5ea035970f3595ff02020dbc55ad819b31e5bfcd2b3e0
+  metadata.gz: 6daff225ff526c8866c59601de914bbf7cac87c0393d5a3918a16f78c249eaa7
+  data.tar.gz: 104deccd41d6dc5fd2be8a263f8549e5190f088717737fed61b9ae9da78aca6d
 SHA512:
-  metadata.gz: bf5f9ee7465d4120a7c343954fd912c07a14e90b23ecee94dca4c9ba077be0d2c3d2853540c74b243f715f4e30cd00e90587e189abac66e043e5a30baab7ea07
-  data.tar.gz: f31753943431a52b0296de465a6d7f2901657a2c4be1c69fc0c91f424011bfbb12f5ad5baa090e236ddf3466b70463cf5098a3ecb72e712af8290e3ea13a85e9
+  metadata.gz: 539c3dfd3b611f79341f32b8eb61db2c76d0c92fd3e2e3d7312dd6d1946ec51463ac7f7f8db09e663a8681e9afc065f5cf0b7a5788d5129ca6e08d5b4870ce28
+  data.tar.gz: 642ca3c211d11e1b6613a6910ed618685d9a87ae3057438f7f5ab3ccc63dba26041691a4a81309b77e41b682b86ad4aefe6789631fd3b0ddccb11b882d959947

data/lib/graphlyte/arguments/set.rb

@@ -0,0 +1,75 @@
+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 extract_variables(values=@values, variables=[])
+        values&.each do |key, value|
+          if value.is_a?(Set)
+            variables.concat extract_variables(value.values)
+          elsif value.symbol?
+            variables << value
+          elsif value.formal?
+            variables << value
+          end
+        end
+        variables
+      end
+
+      def to_h(inner = 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(&:to_s)
+          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
+          end
+          memo
+        end
+      end
+      
+      def to_s(inner = false)
+        return "" unless values && !values.empty?
+        arr = 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
+        return arr.join(", ") if inner
+        "(#{arr.join(", ")})"
+      end
+
+      private 
+
+      def expand_arguments(data)
+        data.inject({}) do |memo, (k, v)|
+          if v.is_a?(Array)
+            memo[k] = v.map do |item|
+              Value.new(item)
+            end
+          elsif v.is_a?(Hash)
+            memo[k] = Set.new(v)
+          else
+            memo[k] = Value.new(v)
+          end
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/arguments/value.rb

@@ -0,0 +1,32 @@
+require_relative "./../refinements/string_refinement"
+module Graphlyte
+  module Arguments
+    class Value
+      using Refinements::StringRefinement
+
+      attr_reader :value
+
+      def initialize(value)
+        raise ArgumentError, "Hash not allowed in this context" if value.is_a? Hash
+        @value = value
+      end
+
+      def symbol?
+        value.is_a? Symbol
+      end
+
+      def formal?
+        value.is_a? Schema::Types::Base
+      end
+
+      def to_s
+        return "$#{value.to_s.to_camel_case}" if value.is_a? Symbol
+        return value if value.is_a? Numeric
+        return "\"#{value}\"" if value.is_a? String
+        return "null" if value.nil?
+        return "$#{value.placeholder.to_camel_case}" if value.is_a? Schema::Types::Base
+        value.to_s
+      end
+    end
+  end
+end

data/lib/graphlyte/builder.rb

@@ -0,0 +1,43 @@
+require_relative "./field"
+require_relative "./fieldset"
+
+module Graphlyte
+  class Builder
+    def initialize(fields = [])
+      @fields = fields
+    end
+
+    def <<(buildable)
+      raise "Must pass a Fieldset or Fragment" unless [Fragment, Fieldset].include?(buildable.class)
+
+      @fields.concat(buildable.fields) if buildable.class.eql? Fieldset
+
+      # todo: handle fragments better, it's not a field
+      @fields << buildable if buildable.class.eql? Fragment
+    end
+    
+    def method_missing(method, fieldset_or_hargs=nil, hargs={}, &block)
+      # todo: camel case method 
+
+      # hack for ruby bug in lower versions
+      if [Fieldset, Fragment].include?(fieldset_or_hargs.class)
+        field = Field.new(method, fieldset_or_hargs, hargs)
+      else
+        field = Field.new(method, Fieldset.empty, fieldset_or_hargs)
+      end
+
+      field.fieldset.builder.>.instance_eval(&block) if block
+      @fields << field
+      field
+    end
+
+    # for internal use only
+    def >>
+      @fields
+    end
+
+    def >
+      self
+    end
+  end
+end

data/lib/graphlyte/field.rb

@@ -0,0 +1,38 @@
+require_relative "./arguments/set"
+require_relative "./refinements/string_refinement"
+module Graphlyte
+  class Field
+    using Refinements::StringRefinement
+
+    attr_reader :name, :fieldset, :inputs, :alias
+
+    def initialize(name, fieldset, hargs, inputs: Arguments::Set.new(hargs))
+      @name = name.to_s.to_camel_case
+      @fieldset = fieldset
+      @inputs = inputs
+      @alias = nil
+    end
+
+    def atomic?
+      fieldset.empty?
+    end   
+
+    def alias(name, &block)
+      @alias = name
+      fieldset.builder.>.instance_eval(&block) if block
+    end
+
+    def to_s(indent=0)
+      str = ""
+      actual_indent = ("\s" * indent) * 2
+      if @alias
+        str += "#{actual_indent}#{@alias}: #{name}"
+        str += inputs.to_s.empty? ? "()" : inputs.to_s 
+      else
+        str += "#{actual_indent}#{name}#{inputs.to_s}"
+      end
+      str += " {\n#{fieldset.to_s(indent + 1)}\n#{actual_indent}}" unless atomic?
+      str
+    end
+  end
+end

data/lib/graphlyte/fieldset.rb

@@ -0,0 +1,36 @@
+require_relative "./builder"
+
+module Graphlyte
+  class Fieldset    
+    def self.empty
+      new
+    end
+
+    attr_reader :model_name, :builder
+
+    def initialize(model_name = nil, builder: Builder.new)
+      @model_name = model_name
+      @builder = builder
+    end
+
+    def fields
+      builder.>>
+    end
+
+    def empty?
+      fields.empty?
+    end
+
+    def to_s(indent=0)
+      fields.map { |field| field.to_s(indent) }.join("\n")
+    end
+
+    def to_a
+      [ to_s ]
+    end
+
+    def +(fieldset)
+      to_s + "\n" + fieldset.to_s
+    end
+  end
+end

data/lib/graphlyte/fragment.rb

@@ -0,0 +1,17 @@
+require_relative "./fieldset"
+
+module Graphlyte
+  class Fragment < Fieldset
+    attr_reader :fragment
+
+    def initialize(fragment_name, model_name=nil, **hargs)
+      @fragment = fragment_name
+      super(model_name, **hargs)
+    end
+
+    def to_s(indent=0)
+      actual_indent = ("\s" * indent) * 2
+      "#{actual_indent}...#{fragment}#{actual_indent}"
+    end
+  end
+end

data/lib/graphlyte/query.rb

@@ -0,0 +1,97 @@
+require_relative "./refinements/string_refinement"
+module Graphlyte
+  class Query < Fieldset
+    using Refinements::StringRefinement
+    attr_reader :name, :type
+
+    def initialize(query_name=nil, type=:query, **hargs)
+      @name = query_name
+      @type = type
+      super(**hargs)
+    end
+
+    def placeholders
+      flatten_variables(builder.>>).map do |value|
+        ":#{value.value.placeholder} of #{value.value.name}"
+      end.join("\n")
+    end
+
+    def to_json(name="anonymousQuery", **hargs)
+      variables = flatten_variables(builder.>>).uniq { |v| v.value }
+      types = merge_variable_types(variables, hargs)
+
+      str = "#{type} #{name}"
+      unless types.empty?
+        type_new = types.map do |type_arr|
+          "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
+        end
+        str += "(#{type_new.join(", ")})"
+      end
+      { query: "#{str} #{to_s(1)}", variables: Arguments::Set.new(hargs).to_h }.to_json
+    end
+
+    def to_s(indent=0)
+      "{\n#{super(indent + 1)}\n}#{format_fragments}"
+    end
+    
+    def merge_variable_types(variables=[], hargs)
+      variables.inject([]) do |memo, var|
+        unless var.formal?
+          if hargs[var.value].is_a? String
+            memo << [var.value.to_camel_case, "String"]
+          elsif [TrueClass, FalseClass].include? hargs[var.value].class
+            memo << [var.value ,"Boolean"]
+          elsif hargs[var.value].is_a? Float
+            memo << [var.value, "Float"]
+          elsif hargs[var.value].is_a? Integer
+            memo << [var.value, "Int"]
+          elsif hargs[var.value].is_a? Array
+            memo <<  "[#{merge_variable_types(var.value, hargs).first}]"
+          end
+        else
+          memo << [var.value.placeholder, var.value.name]
+        end
+        memo
+      end
+    end
+    
+    def format_fragments
+      str = "\n"
+      flatten(builder.>>).each do |_, fragment|
+        str += "\nfragment #{fragment.fragment}"
+        str += " on #{fragment.model_name}" unless fragment.model_name.nil?
+        str += " {\n#{fragment.fields.map {|f| f.to_s(1) }.join("\n")}\n}"
+      end
+      str
+    end
+
+    def flatten_variables(fields, variables=[])
+      fields.each do |field|
+        variables.concat field.inputs.extract_variables unless field.class.eql?(Fragment)
+        if field.class.eql?(Fragment)
+          flatten_variables(field.fields, variables)
+        else
+          flatten_variables(field.fieldset.fields, variables)
+        end
+      end
+      variables
+    end
+
+    def flatten(fields, new_fields = {})
+      fields.each do |field|
+        if field.class.eql?(Fragment)
+          new_fields[field.fragment] = field
+          unless field.empty?
+            flatten(field.fields, new_fields)
+          end
+        else
+          if field.fieldset.class.eql?(Fragment)
+            new_fields[field.fieldset.fragment] = field.fieldset
+          end
+          flatten(field.fieldset.fields, new_fields) unless field.atomic?
+        end
+      end
+      new_fields
+    end
+  end
+end

data/lib/graphlyte/refinements/string_refinement.rb

@@ -0,0 +1,23 @@
+module Graphlyte
+  module Refinements
+    module StringRefinement
+      refine Symbol do 
+        def to_camel_case
+          to_s.to_camel_case
+        end
+      end
+      refine String do 
+        def to_camel_case
+          start_of_string = match(/(^_+)/)&.[](0)
+          end_of_string = match(/(_+$)/)&.[](0)
+      
+          middle = split("_").reject(&:empty?).inject([]) do |memo, str|
+            memo << (memo.empty? ? str : str.capitalize)
+          end.join("")
+        
+          "#{start_of_string}#{middle}#{end_of_string}"
+        end 
+      end
+    end
+  end
+end

data/lib/graphlyte/schema/types/base.rb

@@ -0,0 +1,14 @@
+module Graphlyte
+  module Schema
+    module Types
+      class Base
+        attr_reader :name, :placeholder
+
+        def initialize(name, placeholder)
+          @name = name
+          @placeholder = placeholder
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/schema_query.rb

@@ -0,0 +1,83 @@
+
+module Graphlyte
+  module SchemaQuery
+    def schema_query
+      type_ref_fragment = Graphlyte.fragment('TypeRef', '__Type') do
+        kind
+        name
+        of_type { 
+          kind
+          name
+          of_type {
+            kind
+            name
+            of_type {
+              kind
+              name
+              of_type {
+                kind
+                name
+                of_type {
+                  kind
+                  name
+                  of_type {
+                    kind
+                    name
+                    of_type {
+                      kind
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      end
+
+      input_value_fragment = Graphlyte.fragment('InputValues', '__InputValue') do
+        name
+        description
+        type type_ref_fragment
+        default_value
+      end
+
+      full_type_fragment = Graphlyte.fragment('FullType', '__Type') do
+        kind
+        name
+        description
+        fields(includeDeprecated: true) do
+          name
+          description
+          args input_value_fragment
+          type type_ref_fragment
+          is_deprecated
+          deprecation_reason
+        end
+        input_fields input_value_fragment
+        interfaces type_ref_fragment
+        enum_values(includeDeprecated: true) do
+          name
+          description
+          is_deprecated
+          deprecation_reason
+        end
+        possible_types type_ref_fragment
+      end
+
+      Graphlyte.query do
+        __schema do
+          query_type { name }
+          mutation_type { name }
+          subscription_type { name }
+          types full_type_fragment
+          directives do 
+            name 
+            description
+            args input_value_fragment
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/types.rb

@@ -0,0 +1,9 @@
+require_relative "schema/types/base"
+
+module Graphlyte
+  class Types
+    def method_missing(method, placeholder)
+      Schema::Types::Base.new(method, placeholder)
+    end
+  end
+end

data/lib/graphlyte.rb

@@ -1,174 +1,36 @@
 require 'json'
-module Graphlyte
-  def self.query(name = nil, &block)
-    query = Query.new(name)
-    block.call(query) if block
-    query
-  end
+require_relative "./graphlyte/fieldset"
+require_relative "./graphlyte/query"
+require_relative "./graphlyte/fragment"
+require_relative "./graphlyte/schema_query"
+require_relative "./graphlyte/types"
 
-  def self.fragment(fragment_name, model_name=nil, &block) 
-    fragment = Fragment.new(fragment_name, model_name)
-    block.call(fragment) if block
-    fragment
-  end
-
-  def self.fieldset(model_name=nil, &block)
-    fieldset = Fieldset.new(model_name)
-    block.call(fieldset) if block
-    fieldset
-  end
+module Graphlyte
+  extend SchemaQuery
   
-  module Buildable
-    def <<(buildable)
-      raise "Must pass a Fieldset or Fragment" unless [Fragment, Fieldset].include?(buildable.class)
-      @fields.concat(buildable._fields) if buildable.class.eql? Fieldset
-      @fields << buildable if buildable.class.eql? Fragment
-    end
-    
-    def method_missing(method, optional_fieldset_or_args=nil, hargs={}, &block)
-      field = [Fieldset, Fragment].include?(optional_fieldset_or_args.class) ?
-        Field.new(method, optional_fieldset_or_args, hargs) :
-        Field.new(method, Fieldset.empty, optional_fieldset_or_args)
-      block.call(field.value) if block
-      @fields << field
-      field
-    end
-  end
-
-  class Fieldset
-    include Buildable
-    
-    def self.empty
-      new
-    end
-
-    def initialize(model_name = nil)
-      @model_name = model_name
-      @fields = []
-    end
-
-    def _model_name
-      @model_name
-    end
-
-    def _fields
-      @fields
-    end
+  TYPES = Types.new
 
-    def empty?
-      @fields.empty?
-    end
-
-    def can_validate?
-      !@model_name.nil?
-    end
-
-    def to_s(indent=0)
-      @fields.map { |field| field.to_s(indent)}.join("\n")
-    end
+  def self.query(name = nil, &block)
+    Query.new(name, :query, builder: build(&block))
   end
 
-  class Query < Fieldset
-
-    def initialize(query_name=nil)
-      @query_name = query_name
-      @fields = []
-    end
-
-    def to_json
-      { query: to_s }.to_json
-    end
-
-    def to_s(indent=0)
-      "{\n#{super(indent + 1)}\n}\n#{format_fragments}\n"
-    end
-    
-    def format_fragments
-      str = ""
-      flatten(@fields).each do |_, fragment|
-        str += "\nfragment #{fragment.name}"
-        str += " on #{fragment._model_name}" unless fragment._model_name.nil?
-        str += " {\n#{fragment._fields.map {|f| f.to_s(1) }.join("\n")}\n}"
-      end
-      str
-    end
-
-    def flatten(fields=@fields, new_fields = {})
-      fields.each do |field|
-        if field.class.eql?(Fragment)
-          new_fields[field.name] = field
-          unless field._fields.empty?
-            flatten(field._fields, new_fields)
-          end
-        else
-          if field.value.class.eql?(Fragment)
-            new_fields[field.value.name] = field.value
-            flatten(field.value._fields, new_fields) unless field.value._fields.empty?
-          else
-            flatten(field.value._fields, new_fields) unless field.value._fields.empty?
-          end
-        end
-      end
-      new_fields
-    end
+  def self.mutation(name = nil, &block)
+    Query.new(name, :mutation, builder: build(&block))
   end
 
-  class Fragment < Fieldset
-    attr_reader :fragment_name, :name
-
-    def initialize(fragment_name, model_name=nil)
-      @fragment_name = fragment_name
-      @name = fragment_name
-      super(model_name)
-    end
-
-    def to_s(indent=0)
-      actual_indent = ("\s" * indent) * 2
-      "#{actual_indent}...#{@fragment_name}#{actual_indent}"
-    end
+  def self.fragment(fragment_name, model_name, &block)
+    Fragment.new(fragment_name, model_name, builder: build(&block))
   end
 
-  class FieldArguments
-    def initialize(data)
-      @data = data
-    end
-    
-    def to_s
-      return @data && !@data.empty? ? "(#{@data.map{|k, v| "#{k}: \"#{v}\""}.join(", ")})" : ""
-    end
+  def self.fieldset(model_name=nil, &block)
+    Fieldset.new(model_name, builder: build(&block))
   end
 
-  class Field
-    attr_reader :name, :value, :inputs, :alias
-
-    def initialize(name, value=nil, hargs)
-      @name = name
-      @value = value
-      @inputs = FieldArguments.new(hargs)
-      @alias = nil
-    end
-
-    def atomic?
-      value.empty?
-    end
-
-    def alias(name, &block)
-      @alias = name
-      block.call(value) if block
-    end
+  private
 
-    def to_s(indent=0)
-      str = ""
-      actual_indent = ("\s" * indent) * 2
-      if @alias
-        str += "#{actual_indent}#{@alias}: #{name}"
-        str += inputs.to_s.empty? ? "()" : inputs.to_s 
-        str += " "
-      else
-        str += "#{actual_indent}#{name}#{inputs.to_s}"
-      end
-      str += "{\n#{value.to_s(indent + 1)}#{actual_indent}\n#{actual_indent}}" unless atomic?
-      str
-    end
+  def self.build(&block)
+    builder = Builder.new
+    builder.>.instance_eval(&block)
+    builder
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Sean Gregory
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -45,6 +45,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/graphlyte.rb
+- lib/graphlyte/arguments/set.rb
+- lib/graphlyte/arguments/value.rb
+- lib/graphlyte/builder.rb
+- lib/graphlyte/field.rb
+- lib/graphlyte/fieldset.rb
+- lib/graphlyte/fragment.rb
+- lib/graphlyte/query.rb
+- lib/graphlyte/refinements/string_refinement.rb
+- lib/graphlyte/schema/types/base.rb
+- lib/graphlyte/schema_query.rb
+- lib/graphlyte/types.rb
 homepage: https://rubygems.org/gems/graphlyte
 licenses:
 - MIT
@@ -65,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: craft graphql queries with ruby