graphlyte 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ee4eed2122126ce2d651f0f63210598a48a9fb6a6919a4a20066e932fccdab3
-  data.tar.gz: 7d74b8dc7a8c46e949a5ea035970f3595ff02020dbc55ad819b31e5bfcd2b3e0
+  metadata.gz: 82edd3a321164acd153524e98420c75175deb60d1fd56d28f72f52917e35dac4
+  data.tar.gz: '049a43943a6ba45edff3a73347c903be52f0d4e4d7e9f76a9be50e0e45ed11a6'
 SHA512:
-  metadata.gz: bf5f9ee7465d4120a7c343954fd912c07a14e90b23ecee94dca4c9ba077be0d2c3d2853540c74b243f715f4e30cd00e90587e189abac66e043e5a30baab7ea07
-  data.tar.gz: f31753943431a52b0296de465a6d7f2901657a2c4be1c69fc0c91f424011bfbb12f5ad5baa090e236ddf3466b70463cf5098a3ecb72e712af8290e3ea13a85e9
+  metadata.gz: a1a81b6258e70829db7010ce3c2ca3cdd818dadd0cdc21878c6e10eaefd7baa54d816fd3810c92f330699d905ed5ad00f7865c169f0290e96f4290dbf5cf8160
+  data.tar.gz: b3bc5db253642508d0f9e93c7882525706fe7c9e1ec687e4b7f506a6096a9ba8ecb2a6e6cc1653318467911b70c01243a4bf9f55d7cd22ccf2618cfff912bfbd

data/lib/graphlyte.rb

@@ -1,174 +1,26 @@
 require 'json'
+require_relative "./graphlyte/fieldset"
+require_relative "./graphlyte/query"
+require_relative "./graphlyte/fragment"
+
 module Graphlyte
   def self.query(name = nil, &block)
-    query = Query.new(name)
-    block.call(query) if block
-    query
+    Query.new(name, builder: build(&block))
   end
 
-  def self.fragment(fragment_name, model_name=nil, &block) 
-    fragment = Fragment.new(fragment_name, model_name)
-    block.call(fragment) if block
-    fragment
+  def self.fragment(fragment_name, model_name, &block)
+    Fragment.new(fragment_name, model_name, builder: build(&block))
   end
 
   def self.fieldset(model_name=nil, &block)
-    fieldset = Fieldset.new(model_name)
-    block.call(fieldset) if block
-    fieldset
-  end
-  
-  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
+    Fieldset.new(model_name, builder: build(&block))
   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
-
-    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
-  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
-  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
-  end
-
-  class FieldArguments
-    def initialize(data)
-      @data = data
-    end
-    
-    def to_s
-      return @data && !@data.empty? ? "(#{@data.map{|k, v| "#{k}: \"#{v}\""}.join(", ")})" : ""
-    end
-  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
+    block.call(builder) if block
+    builder
   end
 end

data/lib/graphlyte/arguments/set.rb

@@ -0,0 +1,46 @@
+require_relative "./value"
+module Graphlyte
+  module Arguments
+    class Set
+
+      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 to_s(inner = false)
+        return "" unless values && !values.empty?
+        arr = values.map do |k,v| 
+          if v.is_a?(Array)
+            "#{k}: [#{v.map(&:to_s).join(", ")}]"
+          elsif v.is_a?(Set)
+            "#{k}: { #{v.to_s(true)} }"
+          else
+            "#{k}: #{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,19 @@
+module Graphlyte
+  module Arguments
+    class Value
+      attr_reader :value
+
+      def initialize(value)
+        raise ArgumentError, "Hash not allowed in this context" if value.is_a? Hash
+        @value = value
+      end
+
+      def to_s
+        return value if value.is_a? Numeric
+        return "\"#{value}\"" if value.is_a? String
+        return "null" if value.nil?
+        value.to_s
+      end
+    end
+  end
+end

data/lib/graphlyte/builder.rb

@@ -0,0 +1,39 @@
+require_relative "./field"
+require_relative "./fieldset"
+
+module Graphlyte
+  class Builder
+    def initialize
+      @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
+
+      block.call(field.fieldset.builder) if block
+      @fields << field
+      field
+    end
+
+    # for internal use only
+    def >>
+      @fields
+    end
+  end
+end

data/lib/graphlyte/field.rb

@@ -0,0 +1,47 @@
+require_relative "./arguments/set"
+
+module Graphlyte
+  class Field
+    attr_reader :name, :fieldset, :inputs, :alias
+
+    def initialize(name, fieldset, hargs, inputs: Arguments::Set.new(hargs))
+      @name = to_camel_case(name.to_s)
+      @fieldset = fieldset
+      @inputs = inputs
+      @alias = nil
+    end
+
+    def atomic?
+      fieldset.empty?
+    end   
+
+    def alias(name, &block)
+      @alias = name
+      block.call(fieldset.builder) 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
+
+    def to_camel_case(string)
+      start_of_string = string.match(/(^_+)/)&.[](0)
+      end_of_string = string.match(/(_+$)/)&.[](0)
+  
+      middle = string.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

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,48 @@
+module Graphlyte
+  class Query < Fieldset
+
+    attr_reader :name
+
+    def initialize(query_name=nil, **hargs)
+      @name = query_name
+      super(**hargs)
+    end
+
+    def to_json
+      { query: to_s }.to_json
+    end
+
+    def to_s(indent=0)
+      "{\n#{super(indent + 1)}\n}#{format_fragments}"
+    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(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
+            flatten(field.fieldset.fields, new_fields) unless field.atomic?
+          else
+            flatten(field.fieldset.fields, new_fields) unless field.atomic?
+          end
+        end
+      end
+      new_fields
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Sean Gregory
@@ -45,6 +45,13 @@ 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
 homepage: https://rubygems.org/gems/graphlyte
 licenses:
 - MIT