graphiti 1.0.rc.21 → 1.0.rc.22

data/lib/generators/graphiti/resource_generator.rb

@@ -1,23 +1,23 @@
 $:.unshift File.dirname(__FILE__)
-require 'generator_mixin'
+require "generator_mixin"
 
 module Graphiti
   class ResourceGenerator < ::Rails::Generators::NamedBase
     include GeneratorMixin
 
-    source_root File.expand_path('../templates', __FILE__)
+    source_root File.expand_path("../templates", __FILE__)
 
     argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
 
     class_option :'omit-comments',
       type: :boolean,
       default: false,
-      aliases: ['--omit-comments', '-c'],
-      desc: 'Generate without documentation comments'
-    class_option :'actions',
+      aliases: ["--omit-comments", "-c"],
+      desc: "Generate without documentation comments"
+    class_option :actions,
       type: :array,
       default: nil,
-      aliases: ['--actions', '-a'],
+      aliases: ["--actions", "-a"],
       desc: 'Array of controller actions to support, e.g. "index show destroy"'
 
     desc "This generator creates a resource file at app/resources, as well as corresponding controller/specs/route/etc"
@@ -55,7 +55,7 @@ module Graphiti
     end
 
     def omit_comments?
-      @options['omit-comments']
+      @options["omit-comments"]
     end
 
     def responders?
@@ -63,28 +63,28 @@ module Graphiti
     end
 
     def generate_controller
-      to = File.join('app/controllers', class_path, "#{file_name.pluralize}_controller.rb")
-      template('controller.rb.erb', to)
+      to = File.join("app/controllers", class_path, "#{file_name.pluralize}_controller.rb")
+      template("controller.rb.erb", to)
     end
 
     def generate_application_resource
-      to = File.join('app/resources', class_path, "application_resource.rb")
-      template('application_resource.rb.erb', to)
+      to = File.join("app/resources", class_path, "application_resource.rb")
+      template("application_resource.rb.erb", to)
       require "#{::Rails.root}/#{to}"
     end
 
     def application_resource_defined?
-      'ApplicationResource'.safe_constantize.present?
+      "ApplicationResource".safe_constantize.present?
     end
 
     def generate_route
       # Rails 5.2 adds `plural_route_name`, fallback to `plural_table_name`
-      plural_name = self.try(:plural_route_name) || plural_table_name
+      plural_name = try(:plural_route_name) || plural_table_name
 
       code = "resources :#{plural_name}"
-      code << %{, only: [#{actions.map { |a| ":#{a}" }.join(', ')}]} if actions.length < 5
+      code << %(, only: [#{actions.map { |a| ":#{a}" }.join(", ")}]) if actions.length < 5
       code << "\n"
-      inject_into_file 'config/routes.rb', after: /ApplicationResource.*$\n/ do
+      inject_into_file "config/routes.rb", after: /ApplicationResource.*$\n/ do
         indent(code, 4)
       end
     end
@@ -92,18 +92,18 @@ module Graphiti
     def generate_resource_specs
       opts = {}
       opts[:actions] = @options[:actions] if @options[:actions]
-      invoke 'graphiti:resource_test', [resource_klass], opts
+      invoke "graphiti:resource_test", [resource_klass], opts
     end
 
     def generate_api_specs
       opts = {}
       opts[:actions] = @options[:actions] if @options[:actions]
-      invoke 'graphiti:api_test', [resource_klass], opts
+      invoke "graphiti:api_test", [resource_klass], opts
     end
 
     def generate_resource
-      to = File.join('app/resources', class_path, "#{file_name}_resource.rb")
-      template('resource.rb.erb', to)
+      to = File.join("app/resources", class_path, "#{file_name}_resource.rb")
+      template("resource.rb.erb", to)
       require "#{::Rails.root}/#{to}" if create?
     end
 

data/lib/generators/graphiti/resource_test_generator.rb

@@ -1,21 +1,21 @@
 $:.unshift File.dirname(__FILE__)
-require 'generator_mixin'
+require "generator_mixin"
 
 module Graphiti
   class ResourceTestGenerator < ::Rails::Generators::Base
     include GeneratorMixin
 
-    source_root File.expand_path('../templates', __FILE__)
+    source_root File.expand_path("../templates", __FILE__)
 
     argument :resource, type: :string
     argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
-    class_option :'actions',
+    class_option :actions,
       type: :array,
       default: nil,
-      aliases: ['--actions', '-a'],
+      aliases: ["--actions", "-a"],
       desc: 'Array of controller actions, e.g. "index show destroy"'
 
-    desc 'Generates rspec request specs at spec/api'
+    desc "Generates rspec request specs at spec/api"
     def generate
       generate_resource_specs
     end
@@ -27,18 +27,18 @@ module Graphiti
     end
 
     def dir
-      @resource.gsub('Resource', '').underscore.pluralize
+      @resource.gsub("Resource", "").underscore.pluralize
     end
 
     def generate_resource_specs
-      if actions?('create', 'update', 'destroy')
+      if actions?("create", "update", "destroy")
         to = "spec/resources/#{var}/writes_spec.rb"
-        template('resource_writes_spec.rb.erb', to)
+        template("resource_writes_spec.rb.erb", to)
       end
 
-      if actions?('index', 'show')
+      if actions?("index", "show")
         to = "spec/resources/#{var}/reads_spec.rb"
-        template('resource_reads_spec.rb.erb', to)
+        template("resource_reads_spec.rb.erb", to)
       end
     end
 

data/lib/graphiti.rb

@@ -1,16 +1,16 @@
-require 'json'
-require 'forwardable'
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/hash/conversions' # to_xml
-require 'active_support/concern'
-require 'active_support/time'
+require "json"
+require "forwardable"
+require "active_support/core_ext/string"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/hash/conversions" # to_xml
+require "active_support/concern"
+require "active_support/time"
 
-require 'dry-types'
-require 'graphiti_errors'
+require "dry-types"
+require "graphiti_errors"
 
-require 'jsonapi/serializable'
+require "jsonapi/serializable"
 
 require "graphiti/version"
 require "graphiti/jsonapi_serializable_ext"
@@ -69,8 +69,8 @@ require "graphiti/util/class"
 require "graphiti/util/link"
 require "graphiti/util/remote_serializer"
 require "graphiti/util/remote_params"
-require 'graphiti/adapters/null'
-require 'graphiti/adapters/graphiti_api'
+require "graphiti/adapters/null"
+require "graphiti/adapters/graphiti_api"
 require "graphiti/extensions/extra_attribute"
 require "graphiti/extensions/boolean_attribute"
 require "graphiti/extensions/temp_id"
@@ -78,17 +78,17 @@ require "graphiti/serializer"
 require "graphiti/debugger"
 
 if defined?(ActiveRecord)
-  require 'graphiti/adapters/active_record'
+  require "graphiti/adapters/active_record"
 end
 
 if defined?(Rails)
-  require 'graphiti/railtie'
-  require 'graphiti/rails'
-  require 'graphiti/responders'
+  require "graphiti/railtie"
+  require "graphiti/rails"
+  require "graphiti/responders"
 end
 
 module Graphiti
-  autoload :Base, 'graphiti/base'
+  autoload :Base, "graphiti/base"
 
   def self.included(klass)
     klass.instance_eval do
@@ -108,13 +108,11 @@ module Graphiti
 
   # @api private
   def self.with_context(obj, namespace = nil)
-    begin
-      prior = self.context
-      self.context = { object: obj, namespace: namespace }
-      yield
-    ensure
-      self.context = prior
-    end
+    prior = context
+    self.context = {object: obj, namespace: namespace}
+    yield
+  ensure
+    self.context = prior
   end
 
   def self.config
@@ -192,7 +190,7 @@ module InstanceVariableOverride
     values = super
     if @__graphiti_serializer
       values.reject! do |v|
-        ['__graphiti_serializer', '__graphiti_resource'].include?(v)
+        ["__graphiti_serializer", "__graphiti_resource"].include?(v)
       end
     end
     values

data/lib/graphiti/adapters/abstract.rb

@@ -17,7 +17,7 @@ module Graphiti
           belongs_to: ::Graphiti::Sideload::BelongsTo,
           has_one: ::Graphiti::Sideload::HasOne,
           many_to_many: ::Graphiti::Sideload::ManyToMany,
-          polymorphic_belongs_to: ::Graphiti::Sideload::PolymorphicBelongsTo
+          polymorphic_belongs_to: ::Graphiti::Sideload::PolymorphicBelongsTo,
         }
       end
 
@@ -33,7 +33,7 @@ module Graphiti
             :suffix,
             :not_suffix,
             :match,
-            :not_match
+            :not_match,
           ],
           uuid: [:eq, :not_eq],
           integer_id: numerical_operators,
@@ -44,7 +44,7 @@ module Graphiti
           date: numerical_operators,
           datetime: numerical_operators,
           hash: [:eq],
-          array: [:eq]
+          array: [:eq],
         }
       end
 
@@ -120,18 +120,6 @@ module Graphiti
         raise Errors::AdapterNotImplemented.new(self, attribute, :filter_integer_lte)
       end
 
-      def filter_datetime_eq(scope, attribute, value)
-        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_eq)
-      end
-
-      def filter_datetime_not_eq(scope, attribute, value)
-        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_not_eq)
-      end
-
-      def filter_datetime_lte(scope, attribute, value)
-        raise Errors::AdapterNotImplemented.new(self, attribute, :filter_datetime_lte)
-      end
-
       def filter_float_eq(scope, attribute, value)
         raise Errors::AdapterNotImplemented.new(self, attribute, :filter_float_eq)
       end
@@ -233,7 +221,7 @@ module Graphiti
       end
 
       def base_scope(model)
-        raise 'you must override #base_scope in an adapter subclass'
+        raise "you must override #base_scope in an adapter subclass"
       end
 
       # @param scope The scope object we are chaining
@@ -246,7 +234,7 @@ module Graphiti
       #     scope.order(attribute => direction)
       #   end
       def order(scope, attribute, direction)
-        raise 'you must override #order in an adapter subclass'
+        raise "you must override #order in an adapter subclass"
       end
 
       # @param scope The scope object we are chaining
@@ -260,7 +248,7 @@ module Graphiti
       #     scope.page(current_page).per(per_page)
       #   end
       def paginate(scope, current_page, per_page)
-        raise 'you must override #paginate in an adapter subclass'
+        raise "you must override #paginate in an adapter subclass"
       end
 
       # @param scope the scope object we are chaining
@@ -272,7 +260,7 @@ module Graphiti
       #     scope.uniq.count(column)
       #   end
       def count(scope, attr)
-        raise 'you must override #count in an adapter subclass'
+        raise "you must override #count in an adapter subclass"
       end
 
       # @param scope the scope object we are chaining
@@ -283,7 +271,7 @@ module Graphiti
       #     scope.average(attr).to_f
       #   end
       def average(scope, attr)
-        raise 'you must override #average in an adapter subclass'
+        raise "you must override #average in an adapter subclass"
       end
 
       # @param scope the scope object we are chaining
@@ -294,7 +282,7 @@ module Graphiti
       #     scope.sum(attr)
       #   end
       def sum(scope, attr)
-        raise 'you must override #sum in an adapter subclass'
+        raise "you must override #sum in an adapter subclass"
       end
 
       # @param scope the scope object we are chaining
@@ -305,7 +293,7 @@ module Graphiti
       #     scope.maximum(attr)
       #   end
       def maximum(scope, attr)
-        raise 'you must override #maximum in an adapter subclass'
+        raise "you must override #maximum in an adapter subclass"
       end
 
       # @param scope the scope object we are chaining
@@ -316,7 +304,7 @@ module Graphiti
       #     scope.maximum(attr)
       #   end
       def minimum(scope, attr)
-        raise 'you must override #maximum in an adapter subclass'
+        raise "you must override #maximum in an adapter subclass"
       end
 
       # This method must +yield+ the code to run within the transaction.
@@ -332,7 +320,7 @@ module Graphiti
       #
       # @see Resource.model
       def transaction(model_class)
-        raise 'you must override #transaction in an adapter subclass, it must yield'
+        raise "you must override #transaction in an adapter subclass, it must yield"
       end
 
       # Resolve the scope. This is where you'd actually fire SQL,
@@ -359,7 +347,7 @@ module Graphiti
       end
 
       def belongs_to_many_filter(sideload, scope, value)
-        raise 'You must implement #belongs_to_many_filter in an adapter subclass'
+        raise "You must implement #belongs_to_many_filter in an adapter subclass"
       end
 
       def associate_all(parent, children, association_name, association_type)
@@ -377,21 +365,19 @@ module Graphiti
         if activerecord_associate?(parent, child, association_name)
           activerecord_adapter.associate \
             parent, child, association_name, association_type
-        else
-          if [:has_many, :many_to_many].include?(association_type)
-            if parent.send(:"#{association_name}").nil?
-              parent.send(:"#{association_name}=", [child])
-            else
-              parent.send(:"#{association_name}") << child
-            end
+        elsif [:has_many, :many_to_many].include?(association_type)
+          if parent.send(:"#{association_name}").nil?
+            parent.send(:"#{association_name}=", [child])
           else
-            parent.send(:"#{association_name}=", child)
+            parent.send(:"#{association_name}") << child
           end
+        else
+          parent.send(:"#{association_name}=", child)
         end
       end
 
       def disassociate(parent, child, association_name, association_type)
-        raise 'you must override #disassociate in an adapter subclass'
+        raise "you must override #disassociate in an adapter subclass"
       end
 
       def build(model_class)
@@ -406,19 +392,19 @@ module Graphiti
       end
 
       def save(model_instance)
-        raise 'you must override #save in an adapter subclass'
+        raise "you must override #save in an adapter subclass"
       end
 
       def destroy(model_instance)
-        raise 'you must override #destroy in an adapter subclass'
+        raise "you must override #destroy in an adapter subclass"
       end
 
-      private
-
       def self.numerical_operators
-        [:eq, :not_eq, :gt, :gte, :lt, :lte]
+        [:eq, :not_eq, :gt, :gte, :lt, :lte].freeze
       end
 
+      private
+
       def activerecord_adapter
         @activerecord_adapter ||=
           ::Graphiti::Adapters::ActiveRecord.new(resource)

data/lib/graphiti/adapters/active_record.rb

@@ -1,40 +1,40 @@
 module Graphiti
   module Adapters
     class ActiveRecord < ::Graphiti::Adapters::Abstract
-      require 'graphiti/adapters/active_record/inferrence'
-      require 'graphiti/adapters/active_record/has_many_sideload'
-      require 'graphiti/adapters/active_record/belongs_to_sideload'
-      require 'graphiti/adapters/active_record/has_one_sideload'
-      require 'graphiti/adapters/active_record/many_to_many_sideload'
+      require "graphiti/adapters/active_record/inferrence"
+      require "graphiti/adapters/active_record/has_many_sideload"
+      require "graphiti/adapters/active_record/belongs_to_sideload"
+      require "graphiti/adapters/active_record/has_one_sideload"
+      require "graphiti/adapters/active_record/many_to_many_sideload"
 
       def self.sideloading_classes
         {
           has_many: Graphiti::Adapters::ActiveRecord::HasManySideload,
           has_one: Graphiti::Adapters::ActiveRecord::HasOneSideload,
           belongs_to: Graphiti::Adapters::ActiveRecord::BelongsToSideload,
-          many_to_many: Graphiti::Adapters::ActiveRecord::ManyToManySideload
+          many_to_many: Graphiti::Adapters::ActiveRecord::ManyToManySideload,
         }
       end
 
       def filter_eq(scope, attribute, value)
         scope.where(attribute => value)
       end
-      alias :filter_integer_eq :filter_eq
-      alias :filter_float_eq :filter_eq
-      alias :filter_big_decimal_eq :filter_eq
-      alias :filter_date_eq :filter_eq
-      alias :filter_boolean_eq :filter_eq
-      alias :filter_uuid_eq :filter_eq
+      alias filter_integer_eq filter_eq
+      alias filter_float_eq filter_eq
+      alias filter_big_decimal_eq filter_eq
+      alias filter_date_eq filter_eq
+      alias filter_boolean_eq filter_eq
+      alias filter_uuid_eq filter_eq
 
       def filter_not_eq(scope, attribute, value)
         scope.where.not(attribute => value)
       end
-      alias :filter_integer_not_eq :filter_not_eq
-      alias :filter_float_not_eq :filter_not_eq
-      alias :filter_big_decimal_not_eq :filter_not_eq
-      alias :filter_date_not_eq :filter_not_eq
-      alias :filter_boolean_not_eq :filter_not_eq
-      alias :filter_uuid_not_eq :filter_not_eq
+      alias filter_integer_not_eq filter_not_eq
+      alias filter_float_not_eq filter_not_eq
+      alias filter_big_decimal_not_eq filter_not_eq
+      alias filter_date_not_eq filter_not_eq
+      alias filter_boolean_not_eq filter_not_eq
+      alias filter_uuid_not_eq filter_not_eq
 
       def filter_string_eq(scope, attribute, value, is_not: false)
         column = column_for(scope, attribute)
@@ -43,7 +43,7 @@ module Graphiti
       end
 
       def filter_string_eql(scope, attribute, value, is_not: false)
-        clause = { attribute => value }
+        clause = {attribute => value}
         is_not ? scope.where.not(clause) : scope.where(clause)
       end
 
@@ -92,45 +92,45 @@ module Graphiti
         column = column_for(scope, attribute)
         scope.where(column.gt_any(value))
       end
-      alias :filter_integer_gt :filter_gt
-      alias :filter_float_gt :filter_gt
-      alias :filter_big_decimal_gt :filter_gt
-      alias :filter_datetime_gt :filter_gt
-      alias :filter_date_gt :filter_gt
+      alias filter_integer_gt filter_gt
+      alias filter_float_gt filter_gt
+      alias filter_big_decimal_gt filter_gt
+      alias filter_datetime_gt filter_gt
+      alias filter_date_gt filter_gt
 
       def filter_gte(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.gteq_any(value))
       end
-      alias :filter_integer_gte :filter_gte
-      alias :filter_float_gte :filter_gte
-      alias :filter_big_decimal_gte :filter_gte
-      alias :filter_datetime_gte :filter_gte
-      alias :filter_date_gte :filter_gte
+      alias filter_integer_gte filter_gte
+      alias filter_float_gte filter_gte
+      alias filter_big_decimal_gte filter_gte
+      alias filter_datetime_gte filter_gte
+      alias filter_date_gte filter_gte
 
       def filter_lt(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.lt_any(value))
       end
-      alias :filter_integer_lt :filter_lt
-      alias :filter_float_lt :filter_lt
-      alias :filter_big_decimal_lt :filter_lt
-      alias :filter_datetime_lt :filter_lt
-      alias :filter_date_lt :filter_lt
+      alias filter_integer_lt filter_lt
+      alias filter_float_lt filter_lt
+      alias filter_big_decimal_lt filter_lt
+      alias filter_datetime_lt filter_lt
+      alias filter_date_lt filter_lt
 
       def filter_lte(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.lteq_any(value))
       end
-      alias :filter_integer_lte :filter_lte
-      alias :filter_float_lte :filter_lte
-      alias :filter_big_decimal_lte :filter_lte
-      alias :filter_date_lte :filter_lte
+      alias filter_integer_lte filter_lte
+      alias filter_float_lte filter_lte
+      alias filter_big_decimal_lte filter_lte
+      alias filter_date_lte filter_lte
 
       # Ensure fractional seconds don't matter
       def filter_datetime_eq(scope, attribute, value, is_not: false)
-        ranges = value.map { |v| (v..v+1.second-0.00000001) }
-        clause = { attribute => ranges }
+        ranges = value.map { |v| (v..v + 1.second - 0.00000001) }
+        clause = {attribute => ranges}
         is_not ? scope.where.not(clause) : scope.where(clause)
       end
 
@@ -139,7 +139,7 @@ module Graphiti
       end
 
       def filter_datetime_lte(scope, attribute, value)
-        value = value.map { |v| v + 1.second-0.00000001 }
+        value = value.map { |v| v + 1.second - 0.00000001 }
         column = scope.klass.arel_table[attribute]
         scope.where(column.lteq_any(value))
       end
@@ -239,9 +239,8 @@ module Graphiti
       def disassociate(parent, child, association_name, association_type)
         if association_type == :many_to_many
           parent.send(association_name).delete(child)
-        else
-          # Nothing to do here, happened when we merged foreign key
         end
+        # Nothing to do in the else case, happened when we merged foreign key
       end
 
       # (see Adapters::Abstract#create)
@@ -258,11 +257,6 @@ module Graphiti
         instance
       end
 
-      def destroy(model)
-        model.destroy
-        model
-      end
-
       def save(model_instance)
         model_instance.save
         model_instance
@@ -277,7 +271,7 @@ module Graphiti
 
       def column_for(scope, name)
         table = scope.klass.arel_table
-        if other = scope.attribute_alias(name)
+        if (other = scope.attribute_alias(name))
           table[other]
         else
           table[name]