graphiform 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8626c94d7e632cf64e3052e0e1edd4fdbcd0aa520c67458a69d0f686dcfab261
+  data.tar.gz: c06a1caae7f897f315f5c32606e6cc6180531518904fee20e76f2beae4498b7a
+SHA512:
+  metadata.gz: 6db928db886d71484bc930d6e42917e1cadbc72e2d6d360aa7c46bf005aa66a0eacb62957d81497d6d01d132ec1be1de85c2da1a76fb8bed372048e262c8316f
+  data.tar.gz: 2bebd2c05fa86e751e3b7902651fa82071a22a4a43fad562b7af852dafe971d3db0dd275606650bd681b9596326f270d4c07c6b5e380fcdd387dd50288150022

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 jayce.pulsipher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Graphiform
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphiform'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install graphiform
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Graphiform'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/graphiform.rb

@@ -0,0 +1,19 @@
+require 'scopiform'
+
+require 'graphiform/skeleton'
+
+require 'graphiform/active_record_helpers'
+require 'graphiform/core'
+require 'graphiform/fields'
+
+module Graphiform
+  def self.included(base)
+    base.class_eval do
+      include Scopiform
+
+      include Graphiform::ActiveRecordHelpers
+      include Graphiform::Core
+      include Graphiform::Fields
+    end
+  end
+end

data/lib/graphiform/active_record_helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Graphiform
+  module ActiveRecordHelpers
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def preferred_name(name_to_prefer = nil)
+        @preferred_name ||= nil # Define to avoid instance variable not initialized warnings
+        @preferred_name = name_to_prefer if name_to_prefer.present?
+
+        @preferred_name || name
+      end
+    end
+  end
+end

data/lib/graphiform/core.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+require 'graphiform/helpers'
+
+module Graphiform
+  module Core
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def graphql_type
+        local_demodulized_name = demodulized_name
+        Helpers.get_const_or_create(local_demodulized_name, ::Types) do
+          Class.new(::Types::BaseObject) do
+            graphql_name local_demodulized_name
+          end
+        end
+      end
+
+      def graphql_input
+        local_demodulized_name = demodulized_name
+        Helpers.get_const_or_create(local_demodulized_name, ::Inputs) do
+          Class.new(::Inputs::BaseInput) do
+            graphql_name "#{local_demodulized_name}Input"
+          end
+        end
+      end
+
+      def graphql_filter
+        unless defined? @filter
+          local_demodulized_name = demodulized_name
+          @filter = Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Filters) do
+            Class.new(::Inputs::Filters::BaseFilter) do
+              graphql_name "#{local_demodulized_name}Filter"
+            end
+          end
+          @filter.class_eval do
+            argument 'OR', [self], required: false
+          end
+        end
+
+        @filter
+      end
+
+      def graphql_sort
+        local_demodulized_name = demodulized_name
+        Helpers.get_const_or_create(local_demodulized_name, ::Inputs::Sorts) do
+          Class.new(::Inputs::Sorts::BaseSort) do
+            graphql_name "#{local_demodulized_name}Sort"
+          end
+        end
+      end
+
+      def graphql_edge
+        Helpers.get_const_or_create("#{demodulized_name}Edge", ::Types) do
+          node_type = graphql_type
+          Class.new(::Types::BaseEdge) do
+            node_type(node_type)
+          end
+        end
+      end
+
+      def graphql_connection
+        connection_name = "#{demodulized_name}Connection"
+        Helpers.get_const_or_create(connection_name, ::Types) do
+          edge_type = graphql_edge
+          Class.new(::Types::BaseConnection) do
+            graphql_name connection_name
+            edge_type(edge_type)
+          end
+        end
+      end
+
+      def graphql_base_resolver
+        unless defined? @base_resolver
+          @base_resolver = Helpers.get_const_or_create(demodulized_name, ::Resolvers) do
+            Class.new(::Resolvers::BaseResolver) do
+              # Default resolver just returns the object to prevent exceptions
+              define_method :resolve do |**_args|
+                object
+              end
+            end
+          end
+
+          local_graphql_filter = graphql_filter
+          local_graphql_sort = graphql_sort
+
+          @base_resolver.class_eval do
+            argument :where, local_graphql_filter, required: false
+            argument :sort, local_graphql_sort, required: false unless local_graphql_sort.arguments.empty?
+          end
+        end
+
+        @base_resolver
+      end
+
+      def graphql_query
+        Helpers.get_const_or_create(demodulized_name, ::Resolvers::Queries) do
+          model = self
+          local_graphql_type = graphql_type
+          Class.new(graphql_base_resolver) do
+            type local_graphql_type, null: false
+
+            define_method :resolve do |where: nil|
+              val = model.all
+              val = val.apply_filters(where.to_h) if where.present? && val.respond_to?(:apply_filters)
+
+              val.first
+            end
+          end
+        end
+      end
+
+      def graphql_connection_query
+        Helpers.get_const_or_create(demodulized_name, ::Resolvers::ConnectionQueries) do
+          model = self
+          connection_type = graphql_connection
+          Class.new(graphql_base_resolver) do
+            type connection_type, null: false
+
+            define_method :resolve do |where: nil, sort: nil|
+              val = model.all
+              val = val.apply_filters(where.to_h) if where.present? && val.respond_to?(:apply_filters)
+              val = val.apply_sorts(sort.to_h) if sort.present? && val.respond_to?(:apply_sorts)
+
+              val
+            end
+          end
+        end
+      end
+
+      def graphql_create_resolver(method_name, resolver_type = graphql_type)
+        Class.new(graphql_base_resolver) do
+          type resolver_type, null: false
+
+          define_method :resolve do |where: nil, **args|
+            where_hash = where.to_h
+
+            val = super(**args)
+
+            val = val.public_send(method_name) if val.respond_to? method_name
+
+            return val.apply_filters(where_hash) if val.respond_to? :apply_filters
+
+            val
+          end
+        end
+      end
+
+      def graphql_create_enum(enum_name)
+        enum_name = enum_name.to_s
+        enum_options = defined_enums[enum_name] || {}
+
+        enum_class_name = "#{demodulized_name}#{enum_name.pluralize.capitalize}"
+        Helpers.get_const_or_create(enum_class_name, ::Enums) do
+          Class.new(::Enums::BaseEnum) do
+            enum_options.each_key do |key|
+              value key
+            end
+          end
+        end
+      end
+
+      private
+
+      def demodulized_name
+        preferred_name.demodulize
+      end
+    end
+  end
+end

data/lib/graphiform/fields.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Graphiform
+  module Fields
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def graphql_readable_field(
+        name,
+        **options
+      )
+        column_def = column(name)
+        association_def = association(name)
+
+        graphql_add_column_field(name, column_def, **options) if column_def.present?
+        graphql_add_association_field(name, association_def, **options) if association_def.present?
+        graphql_add_method_field(name, **options) unless column_def.present? || association_def.present?
+
+        graphql_add_scopes_to_filter(name)
+        graphql_field_to_sort(name)
+      end
+
+      def graphql_writable_field(
+        name,
+        type: nil,
+        required: false,
+        **_options
+      )
+        name = name.to_sym
+        argument_name = graphql_resolve_argument_name(name)
+        argument_type = graphql_resolve_argument_type(name, type)
+
+        return Helpers.logger.warn "Graphiform: Missing `type` for argument #{name}" if argument_type.nil?
+
+        graphql_input.class_eval do
+          argument argument_name, argument_type, required: required
+        end
+      end
+
+      def graphql_field(
+        name,
+        write_name: nil,
+        readable: true,
+        writable: false,
+        **options
+      )
+        graphql_readable_field(name, **options) if readable
+        graphql_writable_field(write_name || name, **options) if writable
+      end
+
+      def graphql_fields(*names, **options)
+        names.each do |name|
+          graphql_field(name, **options)
+        end
+      end
+
+      def graphql_readable_fields(*names, **options)
+        names.each do |name|
+          graphql_readable_field(name, **options)
+        end
+      end
+
+      def graphql_writable_fields(*names, **options)
+        names.each do |name|
+          graphql_writable_field(name, **options)
+        end
+      end
+
+      private
+
+      def graphql_resolve_argument_name(name)
+        attributes_name = "#{name}_attributes"
+
+        return attributes_name.to_sym if instance_methods.include?("#{attributes_name}=".to_sym)
+
+        name
+      end
+
+      def graphql_resolve_argument_type(name, type)
+        return type if type.present?
+
+        column_def = column(name)
+
+        return Helpers.graphql_type(column_def.type) if column_def.present?
+
+        association_def = association(name)
+
+        return nil unless Helpers.association_arguments_valid?(association_def, :graphql_input)
+
+        has_many = association_def.macro == :has_many
+        has_many ? [association_def.klass.graphql_input] : association_def.klass.graphql_input
+      end
+
+      def graphql_add_scopes_to_filter(name)
+        added_scopes = auto_scopes_by_attribute(name)
+
+        return if added_scopes.empty?
+
+        association_def = association(name)
+
+        if association_def.present?
+          return unless Helpers.association_arguments_valid?(association_def, :graphql_filter)
+
+          type = association_def.klass.graphql_filter
+        end
+
+        non_sort_by_scopes = added_scopes.select { |scope_def| !scope_def.options || scope_def.options[:type] != :sort }
+
+        non_sort_by_scopes.each do |added_scope|
+          scope_argument_type = type || added_scope.options[:argument_type]
+          if added_scope.options[:type] == :enum
+            enum = graphql_create_enum(name)
+            scope_argument_type = scope_argument_type.is_a?(Array) ? [enum] : enum
+          end
+          add_scope_def_to_filter(added_scope, scope_argument_type)
+        end
+      end
+
+      def add_scope_def_to_filter(scope_def, argument_type)
+        return unless argument_type
+
+        argument_type = Helpers.graphql_type(argument_type)
+        camelized_attribute = scope_def.attribute.to_s.camelize(:lower)
+        argument_prefix = scope_def.prefix
+        argument_suffix = scope_def.suffix
+        argument_suffix = argument_suffix == '_is' ? '' : argument_suffix
+        argument_name = "#{argument_prefix}#{camelized_attribute}#{argument_suffix}"
+        scope_name = scope_def.name
+
+        graphql_filter.class_eval do
+          argument(
+            argument_name,
+            argument_type,
+            required: false,
+            camelize: false,
+            as: scope_name
+          )
+        end
+      end
+
+      def graphql_field_to_sort(name)
+        column_def = column(name)
+        association_def = association(name)
+
+        type = ::Enums::Sort if column_def.present?
+        type = association_def.klass.graphql_sort if Helpers.association_arguments_valid?(association_def, :graphql_sort)
+
+        return if type.blank?
+
+        local_graphql_sort = graphql_sort
+
+        local_graphql_sort.class_eval do
+          argument(
+            name,
+            type,
+            required: false
+          )
+        end
+      end
+
+      def graphql_add_field_to_type(field_name, type, null = nil)
+        field_name = field_name.to_sym
+        field_options = {}
+
+        if Helpers.resolver?(type)
+          field_options[:resolver] = type
+        else
+          field_options[:type] = type
+          field_options[:null] = null
+        end
+
+        graphql_type.class_eval do
+          field(field_name, **field_options)
+        end
+      end
+
+      def graphql_add_column_field(field_name, column_def, type: nil, null: nil, **_options)
+        type = :string if type.blank? && enum_attribute?(field_name)
+        type = Helpers.graphql_type(type || column_def.type)
+        null = column_def.null if null.nil?
+
+        graphql_add_field_to_type(field_name, type, null)
+      end
+
+      def graphql_add_association_field(field_name, association_def, type: nil, null: nil, **_options)
+        unless association_def.klass.respond_to?(:graphql_type)
+          return Helpers.logger.warn(
+            "Graphiform: `#{name}` trying to add association `#{field_name}` - `#{association_def.klass.name}` does not include Graphiform"
+          )
+        end
+
+        if association_def.klass.graphql_type.fields.empty?
+          return Helpers.logger.warn(
+            "Graphiform: `#{name}` trying to add association `#{field_name}` - `#{association_def.klass.name}` has no fields defined"
+          )
+        end
+
+        has_many = association_def.macro == :has_many
+        klass = association_def.klass
+
+        if has_many
+          graphql_add_field_to_type(
+            "#{field_name}_connection",
+            klass.graphql_create_resolver(association_def.name, graphql_connection),
+            false
+          )
+        end
+
+        type = has_many ? klass.graphql_create_resolver(association_def.name, [klass.graphql_type]) : klass.graphql_type if type.nil?
+        null = association_def.macro != :has_many if null.nil?
+
+        graphql_add_field_to_type(field_name, type, null)
+      end
+
+      def graphql_add_method_field(field_name, type:, null: true, **_options)
+        return Helpers.logger.warn "Graphiform: Missing `type` for field `#{field_name}` in model `#{name}`" if type.nil?
+
+        graphql_add_field_to_type(field_name, type, null)
+      end
+    end
+  end
+end

data/lib/graphiform/helpers.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Graphiform
+  module Helpers
+    def self.logger
+      return Rails.logger if Rails.logger.present?
+
+      @logger ||= Logger.new(STDOUT)
+      @logger
+    end
+
+    def self.graphql_type(active_record_type)
+      is_array = active_record_type.is_a? Array
+      active_record_type = is_array ? active_record_type[0] : active_record_type
+      graphql_type = graphql_type_single(active_record_type)
+      is_array ? [graphql_type] : graphql_type
+    end
+
+    def self.graphql_type_single(active_record_type)
+      return active_record_type unless active_record_type.respond_to?(:to_sym)
+
+      case active_record_type.to_sym
+      when :string, :text
+        GraphQL::Types::String
+      when :date
+        GraphQL::Types::ISO8601Date
+      when :time, :datetime, :timestamp
+        GraphQL::Types::ISO8601DateTime
+      when :integer
+        GraphQL::Types::Int
+      when :float, :decimal
+        GraphQL::Types::Float
+      when :boolean
+        GraphQL::Types::Boolean
+      else
+        active_record_type
+      end
+    end
+
+    def self.resolver?(val)
+      val.respond_to?(:ancestors) &&
+        val.ancestors.include?(GraphQL::Schema::Resolver)
+    end
+
+    def self.get_const_or_create(const, mod = Object)
+      new_full_const_name = full_const_name("#{mod}::#{const}")
+      new_full_const_name.constantize
+      Object.const_get(new_full_const_name)
+    rescue NameError => e
+      unless full_const_name(e.missing_name) == new_full_const_name.to_s
+        logger.warn "Failed to load #{e.missing_name} when loading constant #{new_full_const_name}"
+        return Object.const_get(new_full_const_name)
+      end
+
+      val = yield
+      mod.const_set(const, val)
+      val
+    end
+
+    def self.full_const_name(name)
+      name = "Object#{name}" if name.starts_with?('::')
+      name = "Object::#{name}" unless name.starts_with?('Object::')
+
+      name
+    end
+
+    def self.association_arguments_valid?(association_def, method)
+      association_def.present? &&
+        association_def.klass.respond_to?(method) &&
+        association_def.klass.send(method).respond_to?(:arguments) &&
+        !association_def.klass.send(method).arguments.empty?
+    end
+  end
+end

data/lib/graphiform/skeleton.rb

@@ -0,0 +1,107 @@
+require 'graphql'
+require 'graphiform/helpers'
+
+module Graphiform
+  # Types
+  Helpers.get_const_or_create('Types') do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseObject', ::Types) do
+    Class.new(::GraphQL::Schema::Object)
+  end
+
+  Helpers.get_const_or_create('BaseEdge', ::Types) do
+    Class.new(::GraphQL::Types::Relay::BaseEdge)
+  end
+
+  Helpers.get_const_or_create('BaseConnection', ::Types) do
+    Class.new(::GraphQL::Types::Relay::BaseConnection)
+  end
+
+  # Inputs
+  Helpers.get_const_or_create('Inputs') do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseInput', ::Inputs) do
+    Class.new(::GraphQL::Schema::InputObject)
+  end
+
+  Helpers.get_const_or_create('Filters', ::Inputs) do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseFilter', ::Inputs::Filters) do
+    Class.new(::GraphQL::Schema::InputObject)
+  end
+
+  Helpers.get_const_or_create('Sorts', ::Inputs) do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseSort', ::Inputs::Sorts) do
+    Class.new(::GraphQL::Schema::InputObject)
+  end
+
+  # Resolvers
+  Helpers.get_const_or_create('Resolvers') do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseResolver', ::Resolvers) do
+    Class.new(::GraphQL::Schema::Resolver)
+  end
+
+  # Queries
+  Helpers.get_const_or_create('Queries', ::Resolvers) do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseQuery', ::Resolvers::Queries) do
+    Class.new(::GraphQL::Schema::Resolver)
+  end
+
+  # Connection Queries
+  Helpers.get_const_or_create('ConnectionQueries', ::Resolvers) do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseQuery', ::Resolvers::ConnectionQueries) do
+    Class.new(::GraphQL::Schema::Resolver)
+  end
+
+  # Enums
+  Helpers.get_const_or_create('Enums') do
+    Module.new
+  end
+
+  Helpers.get_const_or_create('BaseEnum', ::Enums) do
+    Class.new(::GraphQL::Schema::Enum)
+  end
+
+  Helpers.get_const_or_create('Sort', ::Enums) do
+    Class.new(::Enums::BaseEnum) do
+      value 'ASC', 'Sort results in ascending order'
+      value 'DESC', 'Sort results in descending order'
+    end
+  end
+end
+
+# Types
+#   BaseObject
+#   BaseEdge
+#   BaseConnection
+# Inputs
+#   BaseInput
+# Filters
+#   BaseFilter
+# Resolvers
+#   BaseResolver
+# ConnectionQueries
+
+# Helpers.get_const_or_create('Types') do
+#   Class.new(::Types::BaseObject) do
+#     graphql_name demodulized_name
+#   end
+# end

data/lib/graphiform/version.rb

@@ -0,0 +1,3 @@
+module Graphiform
+  VERSION = '0.1.0'.freeze
+end

data/lib/tasks/graphiform_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :graphiform do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: graphiform
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jayce.pulsipher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: scopiform
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: sqlite3
+  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: warning
+  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: 
+email:
+- jayce.pulsipher@3-form.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/graphiform.rb
+- lib/graphiform/active_record_helpers.rb
+- lib/graphiform/core.rb
+- lib/graphiform/fields.rb
+- lib/graphiform/helpers.rb
+- lib/graphiform/skeleton.rb
+- lib/graphiform/version.rb
+- lib/tasks/graphiform_tasks.rake
+homepage: https://github.com/3-form/graphiform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Generate GraphQL types, inputs, resolvers, queries, and connections based
+  off whitelisted column and association definitions
+test_files: []