graphlyte 0.3.2 → 1.0.0

data/lib/graphlyte/arguments/value.rb

@@ -1,42 +0,0 @@
-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 self.from(value)
-        return value if value.is_a? self
-
-        new(value)
-      end
-
-      def symbol?
-        value.is_a? Symbol
-      end
-
-      def formal?
-        value.is_a? Schema::Types::Base
-      end
-
-      def refresh(args)
-        @value = value.call(args) if value.is_a? Proc
-      end
-
-      def to_s(raw = false)
-        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) && !raw
-        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/arguments/value_literal.rb

@@ -1,17 +0,0 @@
-module Graphlyte
-  module Arguments
-    class ValueLiteral
-      attr_reader :value
-
-      def initialize(string)
-        raise 'Value must be a string' unless string.class == String
-
-        @value = string
-      end
-
-      def to_s
-        @value
-      end
-    end
-  end
-end

data/lib/graphlyte/builder.rb

@@ -1,59 +0,0 @@
-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, InlineFragment].include?(buildable.class)
-
-      @fields.concat(buildable.fields) if buildable.class.eql? Fieldset
-
-      # todo: handle fragments better, it's not a field
-      @fields << buildable if [InlineFragment, Fragment].include? buildable.class
-    end
-
-    def remove(field_symbol)
-      @fields.reject! do |field|
-        field.class == Fragment ? false : field.name == field_symbol.to_s
-      end
-
-      @fields.select { |field| field.class == Fragment }.each do |fragment|
-        fragment.fields.reject! do |field|
-          field.name == field_symbol.to_s
-        end
-      end
-    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, InlineFragment].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
-
-    def respond_to_missing
-      true
-    end
-
-    # for internal use only
-    def >>
-      @fields
-    end
-
-    def >
-      self
-    end
-  end
-end

data/lib/graphlyte/directive.rb

@@ -1,25 +0,0 @@
-require_relative 'arguments/set'
-
-module Graphlyte
-  class Directive
-    attr_reader :name, :inputs
-
-    def initialize(name, **hargs)
-      @name = name
-      @inputs = Arguments::Set.new(hargs)
-    end
-
-    def inflate(indent, string, field: nil, args: nil)
-      # add directive after fieldname?
-      string += ' ' * indent unless indent.nil?
-      if !args.nil? && args.to_s.empty?
-        string += "#{field} " if field
-      else
-        string += "#{field}#{args.to_s} "
-      end
-      string += "@#{name}"
-      string += @inputs.to_s unless @inputs.to_s.empty?
-      string
-    end
-  end
-end

data/lib/graphlyte/field.rb

@@ -1,65 +0,0 @@
-require_relative "./arguments/set"
-require_relative 'directive'
-require_relative "./refinements/string_refinement"
-module Graphlyte
-  class Field
-    using Refinements::StringRefinement
-
-    attr_reader :name, :fieldset, :inputs, :directive
-
-    def initialize(name, fieldset, hargs, directive: nil, inputs: Arguments::Set.new(hargs))
-      @name = name.to_s.to_camel_case
-      @fieldset = fieldset
-      @inputs = inputs
-      @alias = nil
-      @directive = directive
-    end
-
-    def atomic?
-      fieldset.empty?
-    end
-
-    def alias(name, &block)
-      @alias = name
-      if block
-        fieldset.builder.>.instance_eval(&block)
-      else
-        self
-      end
-    end
-
-    def include(**hargs, &block)
-      make_directive('include', **hargs, &block)
-    end
-
-    def skip(**hargs, &block)
-      make_directive('skip', **hargs, &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
-      elsif @directive
-        str = @directive.inflate(indent * 2, str, field: name, args: inputs)
-      else
-        str += "#{actual_indent}#{name}#{inputs.to_s}"
-      end
-      str += " {\n#{fieldset.to_s(indent + 1)}\n#{actual_indent}}" unless atomic?
-      str
-    end
-
-    private
-
-    def method_missing(symbol, **hargs, &block)
-      make_directive(symbol.to_s, **hargs, &block)
-    end
-
-    def make_directive(name, **hargs, &block)
-      @directive = Directive.new(name, **hargs)
-      fieldset.builder.>.instance_eval(&block) if block
-    end
-  end
-end

data/lib/graphlyte/fieldset.rb

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

@@ -1,17 +0,0 @@
-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/inline_fragment.rb

@@ -1,29 +0,0 @@
-require_relative "./fieldset"
-
-module Graphlyte
-  class InlineFragment < Fieldset
-    attr_reader :directive
-
-    def self.from_directive(directive, **hargs)
-      new(nil, directive: directive, **hargs)
-    end
-
-    def initialize(model = nil, directive: nil, **hargs)
-      @directive = directive
-      super(model, **hargs)
-    end
-
-    def to_s(indent=0)
-      actual_indent = ("\s" * indent) * 2
-      string = '...'
-      string += " on #{model_name}" if model_name
-      inflate_indent = model_name ? 1 : 0
-      string = directive.inflate(0, string) if directive
-      string += " {\n"
-      string += super(indent + 1)
-      string += "\n#{actual_indent}}"
-
-      "#{actual_indent}#{string}"
-    end
-  end
-end

data/lib/graphlyte/query.rb

@@ -1,150 +0,0 @@
-require_relative "./refinements/string_refinement"
-require "json"
-module Graphlyte
-  class Selector
-    def initialize(selector)
-      @selector_tokens = selector.split('.')
-    end
-
-    def modify(fields, selector_tokens = @selector_tokens, &block)
-      token = selector_tokens.shift
-
-      if token == '*'
-        fields.each do |field|
-          next if field.class == Fragment
-
-          modify(field.fieldset.fields, [token], &block)
-          field.fieldset.builder.instance_eval(&block) unless field.fieldset.fields.empty?
-        end
-      else
-        needle = fields.find do |field|
-          field.name == token
-        end
-
-        raise "#{token} not found in query" unless needle
-
-        if selector_tokens.size.zero?
-          needle.fieldset.builder.instance_eval(&block)
-        else
-          modify(needle.fieldset.fields, selector_tokens, &block)
-        end
-      end
-    end
-  end
-
-  class Query < Fieldset
-    using Refinements::StringRefinement
-    attr_reader :name, :type
-
-    def initialize(query_name=nil, type=:query, **hargs)
-      @name = query_name || "anonymousQuery"
-      @type = type
-      super(**hargs)
-    end
-
-    def at(selector, &block)
-      Selector.new(selector).modify(fields, &block)
-    end
-
-    def placeholders
-      flatten_variables(builder.>>).map do |value|
-        unless value.formal?
-          str = ":#{value.value.to_sym.inspect} of unknown"
-        else
-          str = ":#{value.value.placeholder} of #{value.value.name}"
-        end
-
-        if value.value.default
-          str += " with default "
-          value.value.default.merge!(str)
-        end
-        str
-      end.join("\n")
-    end
-
-    def to_json(query_name=name, **hargs)
-      variables = flatten_variables(builder.>>).uniq { |v| v.value }
-      types = merge_variable_types(variables, hargs)
-
-      str = "#{type} #{query_name}"
-      unless types.empty?
-        type_new = types.map do |type_arr|
-          type_str = "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
-          unless type_arr[2].nil?
-            type_str << " = "
-            type_arr[2].merge!(type_str)
-          end
-          type_str
-        end
-        str += "(#{type_new.join(", ")})"
-      end
-      { query: "#{str} #{to_s(1)}", variables: Arguments::Set.new(hargs).to_h(true) }.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, var.value.default]
-        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 [InlineFragment, Fragment].include? field.class
-        variables.concat field.directive.inputs.extract_variables if field.respond_to?(:directive) && field.directive
-        if [InlineFragment, Fragment].include? field.class
-          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|
-        next if field.class == InlineFragment
-        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