graphql-rails-activereflection 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f290ca96c78a7e555293a6c0579c148a98cd3cb7
-  data.tar.gz: e9d4d6c77d65f00195cceac332adc08716b1df04
+  metadata.gz: a81c1a5d660000185c3ed8b045308b24c0281982
+  data.tar.gz: fc4b2c58c1c69f13e64ec79ec0707ff0f35a2d77
 SHA512:
-  metadata.gz: c8694fc4b9c0671f1fbf7f5827d9e12a672b676341de78dd4a7fd7eabe5432fa2495e178e882731777edf26dc4c5e1df9e2dd85bc6f61e7dcda242442d9e2fca
-  data.tar.gz: 665656bc9fb5419af9b85571004ad71a304694c5aea3a4629533ebe30059db03b81365bb51e7075c9b0fe78288b101cf13f2ffef125193b963233cadbc7f2253
+  metadata.gz: 9a52d0ba5587ce4af06e4cd7d1e3c656d64319e3eb2613009919e750403fb482fdaa08f394edb6b8a9eb5cce4063ee76738ab1f9cd35bb86c1b69af9b0a064d0
+  data.tar.gz: fcdd14e32bc65f505330aa30e5332d22fb46edf5ba9db87bb2c81efdb730a014947c767a510c258e4555df54ec94d0cd50720641a522e6f5d2c41d8ec20e8fa7

data/README.md

@@ -30,11 +30,12 @@ And that's it! This will add a `_model` field to the object type and enables the
 fragment on YourObjectType {
   _model {
     attributes {
-      name
+      name: String
+      field_name: String
 
       validators {
-        abscence: Boolean
-        prescence: Boolean
+        absence: Boolean
+        presence: Boolean
         uniqueness: Boolean
         with_format: String
         without_format: String
@@ -53,6 +54,9 @@ fragment on YourObjectType {
 }
 ```
 
+The `_model` field will resolve to whatever type `Schema.resolve_type` returns for that object.
+Only the fields on that type will be exposed as `attributes` - where `name` is the attribute name and `field_name` is the field name that exposed the attribute.
+
 Each of the validators corresponds to the standard Rails validators. Almost all validators for an attribute will be returned, **except those that have the `if` or `unless` conditionals.** This is by design and therefore make note that any conditional validations will have to be performed manually.
 
 There is also the `validate(...)` field with arguments for standard scalar types. Any one of the arguments can be provided, but only one. The result will contain a `valid` boolean and a list of `errors` strings returned from the validators.

data/lib/graphql/rails.rb

@@ -0,0 +1,8 @@
+require 'graphql'
+
+module GraphQL
+  module Rails
+  end
+end
+
+require 'graphql/rails/active_reflection'

data/lib/graphql/rails/active_reflection.rb

@@ -1,42 +1,16 @@
-require 'graphql'
+module GraphQL::Rails
+  module ActiveReflection
+    module Types; end
+  end
+end
+
+require 'graphql/rails/active_reflection/version'
+require 'graphql/rails/active_reflection/model'
 require 'graphql/rails/active_reflection/model_reflection'
 require 'graphql/rails/active_reflection/attribute_reflection'
 require 'graphql/rails/active_reflection/validation_result'
 require 'graphql/rails/active_reflection/validator_reflection'
-require 'graphql/rails/active_reflection/types'
-
-module GraphQL
-  module Rails
-    module ActiveReflection
-      VERSION = '0.1.0'
-
-      class UnsupportedObject < StandardError; end
-
-      class Model
-        def self.interface
-          @interface ||= GraphQL::InterfaceType.define do
-            name "ActiveReflectionInterface"
-            field('_model', ModelReflectionType, 'Model of attributes for field.')
-          end
-        end
-
-        def self.field(**kwargs, &block)
-          # We have to define it fresh each time because
-          # its name will be modified and its description
-          # _may_ be modified.
-          field = GraphQL::Field.define do
-            type(GraphQL::Rails::ActiveReflection::Model.interface)
-            description('Fetch the content model for the given object.')
-            resolve(ModelReflection)
-          end
-
-          if kwargs.any? || block
-            field = field.redefine(kwargs, &block)
-          end
-
-          field
-        end
-      end
-    end
-  end
-end
+require 'graphql/rails/active_reflection/types/model_reflection_type'
+require 'graphql/rails/active_reflection/types/attribute_reflection_type'
+require 'graphql/rails/active_reflection/types/validation_result_type'
+require 'graphql/rails/active_reflection/types/validator_type'

data/lib/graphql/rails/active_reflection/attribute_reflection.rb

@@ -1,31 +1,28 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      class AttributeReflection
-        @schema_name = "ActiveReflectionAttribute"
+module GraphQL::Rails::ActiveReflection
+  class AttributeReflection
+    @schema_name = "ActiveReflectionAttribute"
 
-        attr_reader :klass
-        attr_reader :name
-        attr_reader :description
-        attr_reader :validators
+    attr_reader :klass
+    attr_reader :name
+    attr_reader :field_name
+    attr_reader :description
+    attr_reader :validators
 
-        def initialize(field, klass, schema)
-          @klass = klass
-          @name = field.property || field.name
-          @validators = klass.validators.map { |validator|
-            return nil if validator.attributes.exclude? @name
-            return nil if validator.options[:if].present?
-            return nil if validator.options[:unless].present?
-
-            ValidatorReflection.new(validator)
-          }.compact
-          @errors = []
-        end
+    def initialize(field, klass, schema)
+      @klass = klass
+      @field_name = field.name
+      @name = field.property || field.name
+      @validators = klass.validators.map { |validator|
+        # Skip if the validator does not apply to this field
+        # Skip if there are :if or :unless options (conditionals purposely unsupported)
+        next if validator.attributes.exclude?(@name.to_sym) || validator.options[:if].present? || validator.options[:unless].present?
+        GraphQL::Rails::ActiveReflection::ValidatorReflection.new(validator)
+      }.compact
+      @errors = []
+    end
 
-        class << self
-          attr_accessor :schema_name
-        end
-      end
+    class << self
+      attr_accessor :schema_name
     end
   end
 end

data/lib/graphql/rails/active_reflection/model.rb

@@ -0,0 +1,30 @@
+module GraphQL::Rails::ActiveReflection
+  class Model
+    def self.interface
+      @interface ||= GraphQL::InterfaceType.define do
+        name "ActiveReflectionInterface"
+        field('_model', GraphQL::Rails::ActiveReflection::Types::ModelReflectionType, 'Model of attributes for field.') do
+          description('Fetch the content model for the given object.')
+          resolve(GraphQL::Rails::ActiveReflection::ModelReflection)
+        end
+      end
+    end
+
+    def self.field(**kwargs, &block)
+      # We have to define it fresh each time because
+      # its name will be modified and its description
+      # _may_ be modified.
+      field = GraphQL::Field.define do
+        type(GraphQL::Rails::ActiveReflection::Model.interface)
+        description('Fetch the content model for the given object.')
+        resolve(GraphQL::Rails::ActiveReflection::ModelReflection)
+      end
+
+      if kwargs.any? || block
+        field = field.redefine(kwargs, &block)
+      end
+
+      field
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/model_reflection.rb

@@ -1,34 +1,31 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      class ModelReflection
-        @schema_name = "ActiveReflectionModel"
+module GraphQL::Rails::ActiveReflection
+  class ModelReflection
+    @schema_name = "ActiveReflectionModel"
+    @reflections = {}
 
-        def self.call(obj, args, ctx)
-          raise UnsupportedObject unless obj < ActiveRecord::Base
-          @reflections[obj.class] ||= new(obj.class, ctx.schema)
-        end
-
-        attr_reader :attributes
+    def self.call(obj, args, ctx)
+      raise TypeError, "ActiveReflection object type must be derived from ActiveRecord::Base" unless obj.is_a?(ActiveRecord::Base)
+      @reflections[obj] ||= new(obj, ctx)
+    end
 
-        def initialize(klass, schema)
-          @klass = klass
-          @type = schema.resolve_type(@klass)
-          @schema = schema
-          @attributes = @type.fields.map { |field|
-            # No reflection if it's not a model attribute
-            property = field.property || field.name
-            return nil unless klass.attribute_names.include? property
+    attr_reader :attributes
 
-            AttributeReflection.new(field, klass, schema)
-          }.compact
-        end
-
-        class << self
-          attr_accessor :schema_name
+    def initialize(obj, ctx)
+      @klass = obj.class
+      @type = ctx.schema.resolve_type(obj, ctx)
+      @schema = ctx.schema
+      @attributes = @type.fields.map { |name, field|
+        # No reflection if it's not a model attribute
+        property = field.property || name
+        if @klass.attribute_names.include? property
+          GraphQL::Rails::ActiveReflection::AttributeReflection.new(field, @klass, @schema)
         end
+      }.compact
+    end
 
-      end
+    class << self
+      attr_accessor :schema_name
     end
+
   end
 end

data/lib/graphql/rails/active_reflection/types/attribute_reflection_type.rb

@@ -1,36 +1,27 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      module Types
+GraphQL::Rails::ActiveReflection::Types::AttributeReflectionType = GraphQL::ObjectType.define do
+  name GraphQL::Rails::ActiveReflection::AttributeReflection.schema_name
 
-        AttributeReflectionType = ::GraphQL::ObjectType.define do
-          name AttributeReflection.schema_name
+  field :name, !types.String
+  field :field_name, !types.String
+  field :validators, GraphQL::Rails::ActiveReflection::Types::ValidatorType.to_list_type
+  field :validate, GraphQL::Rails::ActiveReflection::Types::ValidationResultType do
+    argument :int, types.Int
+    argument :str, types.String
+    argument :float, types.Float
+    argument :bool, types.Boolean
 
-          field :name, !types.String
-          field :validators, ValidatorType.to_list_type
-          field :validate, ValidationResultType do
-            argument :int, types.Int
-            argument :str, types.String
-            argument :float, types.Float
-            argument :bool, types.Boolean
+    resolve ->(obj, args, _ctx) do
+      values = [args['int'], args['str'], args['float'], args['bool']]
+      raise ArgumentError, "Must specify at least one argument" if values.compact.empty?
+      raise ArgumentError, "Too many arguments, one expected" if values.compact.size > 1
 
-            resolve ->(obj, args, _ctx) do
-              values = [args['int'], args['str'], args['float'], args['bool']]
-              raise ArgumentError, "Must specify at least one argument" if values.compact.empty?
-              raise ArgumentError, "Too many arguments, one expected" if values.compact.size > 1
+      value = values.compact.first
 
-              value = values.compact.first
+      model = obj.klass.new
+      model[obj.name] = value
 
-              model = obj.klass.new
-              model[obj.name] = value
-
-              model.validate!
-              ValidationResult.new(model.valid?, model.errors[obj.name])
-            end
-          end
-        end
-
-      end
+      model.validate!
+      GraphQL::Rails::ActiveReflection::ValidationResult.new(model.valid?, model.errors[obj.name])
     end
   end
 end

data/lib/graphql/rails/active_reflection/types/model_reflection_type.rb

@@ -1,12 +1,4 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      module Types
-        ModelReflectionType = ::GraphQL::ObjectType.define do
-          name ModelReflection.schema_name
-          field :attributes, AttributeReflectionType.to_list_type
-        end
-      end
-    end
-  end
+GraphQL::Rails::ActiveReflection::Types::ModelReflectionType = GraphQL::ObjectType.define do
+  name GraphQL::Rails::ActiveReflection::ModelReflection.schema_name
+  field :attributes, GraphQL::Rails::ActiveReflection::Types::AttributeReflectionType.to_list_type
 end

data/lib/graphql/rails/active_reflection/types/validation_result_type.rb

@@ -1,14 +1,6 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      module Types
-          ValidationResultType = ::GraphQL::ObjectType.define do
-          name ValidationResult.schema_name
+GraphQL::Rails::ActiveReflection::Types::ValidationResultType = GraphQL::ObjectType.define do
+  name GraphQL::Rails::ActiveReflection::ValidationResult.schema_name
 
-          field :valid, types.Boolean
-          field :errors, types.String.to_list_type
-        end
-      end
-    end
-  end
+  field :valid, types.Boolean
+  field :errors, types.String.to_list_type
 end

data/lib/graphql/rails/active_reflection/types/validator_type.rb

@@ -1,77 +1,13 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      module Types
-        ValidatorType = ::GraphQL::ObjectType.define do
-          name ValidatorReflection.schema_name
-          # TODO NumericalityValidator
-
-          field :abscence, types.Boolean do
-            resolve ->(obj, _args, _ctx) do
-              obj < ActiveModel::Validations::AbsenceValidator
-            end
-          end
-
-          field :prescence, types.Boolean do
-            resolve ->(obj, _args, _ctx) do
-              obj < ActiveModel::Validations::PrescenceValidator
-            end
-          end
-
-          field :uniqueness, types.Boolean do
-            resolve ->(obj, _args, _ctx) do
-              obj < ActiveModel::Validations::UniquenessValidator
-            end
-          end
-
-          field :with_format, types.String do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::FormatValidator
-              obj.options[:with]
-            end
-          end
-
-          field :without_format, types.String do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::FormatValidator
-              obj.options[:without]
-            end
-          end
-
-          field :min_length, types.Int do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::LengthValidator
-              obj.options[:minimum]
-            end
-          end
-
-          field :max_length, types.Int do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::LengthValidator
-              obj.options[:maximum]
-            end
-          end
-
-          field :inclusion, types.String.to_list_type do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::InclusionValidator
-              return nil if obj.options[:in].respond_to? :call
-              obj.options[:in]
-            end
-          end
-
-          field :exclusion, types.String.to_list_type do
-            resolve ->(obj, _args, _ctx) do
-              return nil unless obj < ActiveModel::Validations::ExclusionValidator
-              return nil if obj.options[:in].respond_to? :call
-              obj.options[:in]
-            end
-          end
-
-          # TODO AcceptanceValidator (is this relevant anymore?)
-
-        end
-      end
-    end
-  end
+GraphQL::Rails::ActiveReflection::Types::ValidatorType = GraphQL::ObjectType.define do
+  name GraphQL::Rails::ActiveReflection::ValidatorReflection.schema_name
+
+  field :absence, types.Boolean
+  field :presence, types.Boolean
+  field :uniqueness, types.Boolean
+  field :with_format, types.String
+  field :without_format, types.String
+  field :min_length, types.Int
+  field :max_length, types.Int
+  field :inclusion, types.String.to_list_type
+  field :exclusion, types.String.to_list_type
 end

data/lib/graphql/rails/active_reflection/validation_result.rb

@@ -1,21 +1,17 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      class ValidationResult
-        @schema_name = "ActiveReflectionValidation"
+module GraphQL::Rails::ActiveReflection
+  class ValidationResult
+    @schema_name = "ActiveReflectionValidation"
 
-        attr_reader :valid
-        attr_reader :errors
+    attr_reader :valid
+    attr_reader :errors
 
-        def initialize(valid, errors)
-          @valid = valid
-          @errors = errors
-        end
+    def initialize(valid, errors)
+      @valid = valid
+      @errors = errors
+    end
 
-        class << self
-          attr_accessor :schema_name
-        end
-      end
+    class << self
+      attr_accessor :schema_name
     end
   end
 end

data/lib/graphql/rails/active_reflection/validator_reflection.rb

@@ -1,65 +1,89 @@
-module GraphQL
-  module Rails
-    module ActiveReflection
-      class ValidatorReflection
-        @schema_name = "ActiveReflectionValidator"
+require 'active_model'
+require 'active_model/validations'
+require 'active_model/validations/absence'
+require 'active_model/validations/exclusion'
+require 'active_model/validations/format'
+require 'active_model/validations/inclusion'
+require 'active_model/validations/length'
+require 'active_model/validations/presence'
+require 'active_record/validations'
+require 'active_model/validations/absence'
+require 'active_model/validations/length'
+require 'active_model/validations/presence'
+require 'active_record/validations/uniqueness'
 
-        attr_reader :validator
 
-        def initialize(validator)
-          @validator = validator
-        end
+module GraphQL::Rails::ActiveReflection
+  class ValidatorReflection
+    @schema_name = "ActiveReflectionValidator"
 
-        def abscence
-          @validator < ActiveModel::Validations::AbsenceValidator
-        end
+    attr_reader :validator
 
-        def prescence
-          resolve ->(obj, _args, _ctx) do
-            @validator < ActiveModel::Validations::PrescenceValidator
-          end
-        end
+    def initialize(validator)
+      @validator = validator
+    end
 
-        def uniqueness
-          @validator < ActiveModel::Validations::UniquenessValidator
-        end
+    def absence
+      true if [
+        ActiveModel::Validations::AbsenceValidator,
+        ActiveRecord::Validations::AbsenceValidator
+      ].any? { |klass| @validator.is_a? klass }
+    end
 
-        def with_format
-          return nil unless @validator < ActiveModel::Validations::FormatValidator
-          @validator.options[:with]
-        end
+    def presence
+      true if [
+        ActiveModel::Validations::PresenceValidator,
+        ActiveRecord::Validations::PresenceValidator
+      ].any? { |klass| @validator.is_a? klass }
+    end
 
-        def without_format
-          return nil unless @validator < ActiveModel::Validations::FormatValidator
-          @validator.options[:without]
-        end
+    def uniqueness
+      true if @validator.is_a? ActiveRecord::Validations::UniquenessValidator
+    end
 
-        def min_length
-          return nil unless @validator < ActiveModel::Validations::LengthValidator
-          @validator.options[:minimum]
-        end
+    def with_format
+      return nil unless @validator.is_a? ActiveModel::Validations::FormatValidator
+      @validator.options[:with]
+    end
 
-        def max_length
-          return nil unless @validator < ActiveModel::Validations::LengthValidator
-          @validator.options[:maximum]
-        end
+    def without_format
+      return nil unless @validator.is_a? ActiveModel::Validations::FormatValidator
+      @validator.options[:without]
+    end
 
-        def inclusion
-          return nil unless @validator < ActiveModel::Validations::InclusionValidator
-          return nil if @validator.options[:in].respond_to? :call
-          @validator.options[:in]
-        end
+    def min_length
+      return nil unless [
+        ActiveModel::Validations::LengthValidator,
+        ActiveRecord::Validations::LengthValidator
+      ].any? { |klass| @validator.is_a? klass }
+      @validator.options[:minimum]
+    end
+
+    def max_length
+      return nil unless [
+        ActiveModel::Validations::LengthValidator,
+        ActiveRecord::Validations::LengthValidator
+      ].any? { |klass| @validator.is_a? klass }
+      @validator.options[:maximum]
+    end
+
+    def inclusion
+      return nil unless @validator.is_a? ActiveModel::Validations::InclusionValidator
+      return nil if @validator.options[:in].respond_to? :call
+      @validator.options[:in]
+    end
+
+    def exclusion
+      return nil unless @validator.is_a? ActiveModel::Validations::ExclusionValidator
+      return nil if @validator.options[:in].respond_to? :call
+      @validator.options[:in]
+    end
 
-        def exclusion
-          return nil unless @validator < ActiveModel::Validations::ExclusionValidator
-          return nil if @validator.options[:in].respond_to? :call
-          @validator.options[:in]
-        end
+    # TODO NumericalityValidator
+    # TODO AcceptanceValidator (is this relevant anymore?)
 
-        class << self
-          attr_accessor :schema_name
-        end
-      end
+    class << self
+      attr_accessor :schema_name
     end
   end
 end

data/lib/graphql/rails/active_reflection/version.rb

@@ -0,0 +1,7 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      VERSION = '0.1.2'
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-activereflection
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Cole Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-17 00:00:00.000000000 Z
+date: 2017-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -44,6 +44,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  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: Reflection over GraphQL for ActiveRecord models and validators
 email: turner.cole@gmail.com
 executables: []
@@ -53,16 +67,18 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- lib/graphql/rails.rb
 - lib/graphql/rails/active_reflection.rb
 - lib/graphql/rails/active_reflection/attribute_reflection.rb
+- lib/graphql/rails/active_reflection/model.rb
 - lib/graphql/rails/active_reflection/model_reflection.rb
-- lib/graphql/rails/active_reflection/types.rb
 - lib/graphql/rails/active_reflection/types/attribute_reflection_type.rb
 - lib/graphql/rails/active_reflection/types/model_reflection_type.rb
 - lib/graphql/rails/active_reflection/types/validation_result_type.rb
 - lib/graphql/rails/active_reflection/types/validator_type.rb
 - lib/graphql/rails/active_reflection/validation_result.rb
 - lib/graphql/rails/active_reflection/validator_reflection.rb
+- lib/graphql/rails/active_reflection/version.rb
 homepage: http://rubygems.org/gems/graphql-rails-activereflection
 licenses:
 - MIT

data/lib/graphql/rails/active_reflection/types.rb

@@ -1,4 +0,0 @@
-require 'graphql/rails/active_reflection/types/model_reflection_type'
-require 'graphql/rails/active_reflection/types/attribute_reflection_type'
-require 'graphql/rails/active_reflection/types/validation_result_type'
-require 'graphql/rails/active_reflection/types/validator_type'