jsonapi-resources 0.9.0 → 0.10.6

data/lib/tasks/check_upgrade.rake

@@ -0,0 +1,52 @@
+require 'rake'
+require 'jsonapi-resources'
+
+namespace :jsonapi do
+  namespace :resources do
+    desc 'Checks application for orphaned overrides'
+    task :check_upgrade => :environment do
+      Rails.application.eager_load!
+
+      resource_klasses = ObjectSpace.each_object(Class).select { |klass| klass < JSONAPI::Resource}
+
+      puts "Checking #{resource_klasses.count} resources"
+
+      issues_found = 0
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:find_records) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `find_records`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `find_records` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:records_for) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `records_for`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `records_for` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:apply_includes) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `apply_includes`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `apply_includes` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      if issues_found > 0
+        puts "Finished inspection. #{issues_found} issues found that may impact upgrading. Please address these issues. "
+      else
+        puts "Finished inspection with no issues found. Note this is only a cursory check for method overrides that will no \n" \
+             "longer be called by JSONAPI::Resources. This check in no way assures your code will continue to function as \n" \
+             "it did before the upgrade. Please do adequate testing before using in production."
+      end
+    end
+  end
+end

metadata

@@ -1,30 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.6
 platform: ruby
 authors:
 - Dan Gebhardt
 - Larry Gebhardt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2022-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -43,16 +43,22 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 5.10.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 5.10.2
 - !ruby/object:Gem::Dependency
   name: minitest-spec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +115,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  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: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -162,14 +182,20 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
+- lib/bug_report_templates/rails_5_latest.rb
+- lib/bug_report_templates/rails_5_master.rb
 - lib/generators/jsonapi/USAGE
 - lib/generators/jsonapi/controller_generator.rb
 - lib/generators/jsonapi/resource_generator.rb
 - lib/generators/jsonapi/templates/jsonapi_controller.rb
 - lib/generators/jsonapi/templates/jsonapi_resource.rb
 - lib/jsonapi-resources.rb
+- lib/jsonapi/active_relation/adapters/join_left_active_record_adapter.rb
+- lib/jsonapi/active_relation/join_manager.rb
+- lib/jsonapi/active_relation_resource.rb
 - lib/jsonapi/acts_as_resource_controller.rb
-- lib/jsonapi/cached_resource_fragment.rb
+- lib/jsonapi/basic_resource.rb
+- lib/jsonapi/cached_response_fragment.rb
 - lib/jsonapi/callbacks.rb
 - lib/jsonapi/compiled_json.rb
 - lib/jsonapi/configuration.rb
@@ -182,26 +208,31 @@ files:
 - lib/jsonapi/mime_types.rb
 - lib/jsonapi/naive_cache.rb
 - lib/jsonapi/operation.rb
-- lib/jsonapi/operation_dispatcher.rb
 - lib/jsonapi/operation_result.rb
-- lib/jsonapi/operation_results.rb
 - lib/jsonapi/paginator.rb
+- lib/jsonapi/path.rb
+- lib/jsonapi/path_segment.rb
 - lib/jsonapi/processor.rb
 - lib/jsonapi/relationship.rb
-- lib/jsonapi/relationship_builder.rb
 - lib/jsonapi/request_parser.rb
 - lib/jsonapi/resource.rb
 - lib/jsonapi/resource_controller.rb
 - lib/jsonapi/resource_controller_metal.rb
+- lib/jsonapi/resource_fragment.rb
+- lib/jsonapi/resource_id_tree.rb
+- lib/jsonapi/resource_identity.rb
 - lib/jsonapi/resource_serializer.rb
+- lib/jsonapi/resource_set.rb
+- lib/jsonapi/resources/railtie.rb
 - lib/jsonapi/resources/version.rb
 - lib/jsonapi/response_document.rb
 - lib/jsonapi/routing_ext.rb
+- lib/tasks/check_upgrade.rake
 homepage: https://github.com/cerebris/jsonapi-resources
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -209,16 +240,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Easily support JSON API in Rails.
 test_files: []

data/lib/jsonapi/cached_resource_fragment.rb

@@ -1,127 +0,0 @@
-module JSONAPI
-  class CachedResourceFragment
-    def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
-      serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
-      context_json = resource_klass.attribute_caching_context(context).to_json
-      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
-      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
-
-      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-
-      miss_ids = results.select{|k,v| v.nil? }.keys
-      unless miss_ids.empty?
-        find_filters = {resource_klass._primary_key => miss_ids.uniq}
-        find_options = {context: context}
-        resource_klass.find(find_filters, find_options).each do |resource|
-          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
-          results[id] = cr
-        end
-      end
-
-      if JSONAPI.configuration.resource_cache_usage_report_function
-        JSONAPI.configuration.resource_cache_usage_report_function.call(
-          resource_klass.name,
-          cache_ids.size - miss_ids.size,
-          miss_ids.size
-        )
-      end
-
-      return results
-    end
-
-    attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
-                :links_json, :attributes_json, :meta_json,
-                :preloaded_fragments
-
-    def initialize(resource_klass, id, type, context, fetchable_fields, relationships,
-                   links_json, attributes_json, meta_json)
-      @resource_klass = resource_klass
-      @id = id
-      @type = type
-      @context = context
-      @fetchable_fields = Set.new(fetchable_fields)
-
-      # Relationships left uncompiled because we'll often want to insert included ids on retrieval
-      @relationships = relationships
-
-      @links_json = CompiledJson.of(links_json)
-      @attributes_json = CompiledJson.of(attributes_json)
-      @meta_json = CompiledJson.of(meta_json)
-
-      # A hash of hashes
-      @preloaded_fragments ||= Hash.new
-    end
-
-    def to_cache_value
-      {
-        id: id,
-        type: type,
-        fetchable: fetchable_fields,
-        rels: relationships,
-        links: links_json.try(:to_s),
-        attrs: attributes_json.try(:to_s),
-        meta: meta_json.try(:to_s)
-      }
-    end
-
-    def to_real_resource
-      rs = Resource.resource_for(self.type).find_by_keys([self.id], {context: self.context})
-      return rs.try(:first)
-    end
-
-    private
-
-    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-      type = resource_klass._type
-
-      keys = cache_ids.map do |(id, cache_key)|
-        [type, id, cache_key, serializer_config_key, context_key]
-      end
-
-      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
-      return keys.each_with_object({}) do |key, hash|
-        (_, id, _, _) = key
-        if hits.has_key?(key)
-          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
-        else
-          hash[id] = nil
-        end
-      end
-    end
-
-    def self.from_cache_value(resource_klass, context, h)
-      new(
-        resource_klass,
-        h.fetch(:id),
-        h.fetch(:type),
-        context,
-        h.fetch(:fetchable),
-        h.fetch(:rels, nil),
-        h.fetch(:links, nil),
-        h.fetch(:attrs, nil),
-        h.fetch(:meta, nil)
-      )
-    end
-
-    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
-      (id, cache_key) = resource.cache_id
-      json = serializer.object_hash(resource) # No inclusions passed to object_hash
-      cr = self.new(
-        resource_klass,
-        json['id'],
-        json['type'],
-        context,
-        resource.fetchable_fields,
-        json['relationships'],
-        json['links'],
-        json['attributes'],
-        json['meta']
-      )
-
-      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
-      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
-      return [id, cr]
-    end
-
-  end
-end

data/lib/jsonapi/operation_dispatcher.rb

@@ -1,88 +0,0 @@
-module JSONAPI
-  class OperationDispatcher
-
-    def initialize(transaction: lambda { |&block| block.yield },
-                   rollback: lambda { },
-                   server_error_callbacks: [])
-
-      @transaction = transaction
-      @rollback = rollback
-      @server_error_callbacks = server_error_callbacks
-    end
-
-    def process(operations)
-      results = JSONAPI::OperationResults.new
-
-      # Use transactions if more than one operation and if one of the operations can be transactional
-      # Even if transactional transactions won't be used unless the derived OperationsProcessor supports them.
-      transactional = false
-
-      operations.each do |operation|
-        transactional |= operation.transactional?
-      end if JSONAPI.configuration.allow_transactions
-
-      transaction(transactional) do
-        # Links and meta data global to the set of operations
-        operations_meta = {}
-        operations_links = {}
-        operations.each do |operation|
-          results.add_result(process_operation(operation))
-          rollback(transactional) if results.has_errors?
-        end
-        results.meta = operations_meta
-        results.links = operations_links
-      end
-      results
-    end
-
-    private
-
-    def transaction(transactional)
-      if transactional
-        @transaction.call do
-          yield
-        end
-      else
-        yield
-      end
-    end
-
-    def rollback(transactional)
-      if transactional
-        @rollback.call
-      end
-    end
-
-    def process_operation(operation)
-      with_default_handling do 
-        operation.process
-      end        
-    end
-
-    def with_default_handling(&block)
-      block.yield
-    rescue => e
-      if JSONAPI.configuration.exception_class_whitelisted?(e)
-        raise e
-      else
-        @server_error_callbacks.each { |callback|
-          safe_run_callback(callback, e)
-        }
-
-        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
-        Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
-        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
-      end
-    end
-
-    def safe_run_callback(callback, error)
-      begin 
-        callback.call(error)
-      rescue => e
-        Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
-        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
-        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
-      end
-    end
-  end
-end

data/lib/jsonapi/operation_results.rb

@@ -1,35 +0,0 @@
-module JSONAPI
-  class OperationResults
-    attr_accessor :results
-    attr_accessor :meta
-    attr_accessor :links
-
-    def initialize
-      @results = []
-      @has_errors = false
-      @meta = {}
-      @links = {}
-    end
-
-    def add_result(result)
-      @has_errors = true if result.is_a?(JSONAPI::ErrorsOperationResult)
-      @results.push(result)
-    end
-
-    def has_errors?
-      @has_errors
-    end
-
-    def all_errors
-      errors = []
-      if @has_errors
-        @results.each do |result|
-          if result.is_a?(JSONAPI::ErrorsOperationResult)
-            errors.concat(result.errors)
-          end
-        end
-      end
-      errors
-    end
-  end
-end

data/lib/jsonapi/relationship_builder.rb

@@ -1,167 +0,0 @@
-module JSONAPI
-  class RelationshipBuilder
-    attr_reader :model_class, :options, :relationship_class
-    delegate :register_relationship, to: :@resource_class
-
-    def initialize(relationship_class, model_class, options)
-      @relationship_class = relationship_class
-      @model_class        = model_class
-      @resource_class     = options[:parent_resource]
-      @options            = options
-    end
-
-    def define_relationship_methods(relationship_name)
-      # Initialize from an ActiveRecord model's properties
-      if model_class && model_class.ancestors.collect{|ancestor| ancestor.name}.include?('ActiveRecord::Base')
-        model_association = model_class.reflect_on_association(relationship_name)
-        if model_association
-          options[:class_name] ||= model_association.class_name
-        end
-      end
-
-      relationship = register_relationship(
-        relationship_name,
-        relationship_class.new(relationship_name, options)
-      )
-
-      foreign_key = define_foreign_key_setter(relationship.foreign_key)
-
-      case relationship
-      when JSONAPI::Relationship::ToOne
-        associated = define_resource_relationship_accessor(:one, relationship_name)
-        args = [relationship, foreign_key, associated, relationship_name]
-
-        relationship.belongs_to? ? build_belongs_to(*args) : build_has_one(*args)
-      when JSONAPI::Relationship::ToMany
-        associated = define_resource_relationship_accessor(:many, relationship_name)
-
-        build_to_many(relationship, foreign_key, associated, relationship_name)
-      end
-    end
-
-    def define_foreign_key_setter(foreign_key)
-      define_on_resource "#{foreign_key}=" do |value|
-        @model.method("#{foreign_key}=").call(value)
-      end
-      foreign_key
-    end
-
-    def define_resource_relationship_accessor(type, relationship_name)
-      associated_records_method_name = {
-        one:  "record_for_#{relationship_name}",
-        many: "records_for_#{relationship_name}"
-      }
-      .fetch(type)
-
-      define_on_resource associated_records_method_name do |options = {}|
-        relationship = self.class._relationships[relationship_name]
-        relation_name = relationship.relation_name(context: @context)
-        records = records_for(relation_name)
-
-        resource_klass = relationship.resource_klass
-
-        filters = options.fetch(:filters, {})
-        unless filters.nil? || filters.empty?
-          records = resource_klass.apply_filters(records, filters, options)
-        end
-
-        sort_criteria =  options.fetch(:sort_criteria, {})
-        unless sort_criteria.nil? || sort_criteria.empty?
-          order_options = relationship.resource_klass.construct_order_options(sort_criteria)
-          records = resource_klass.apply_sort(records, order_options, @context)
-        end
-
-        paginator = options[:paginator]
-        if paginator
-          records = resource_klass.apply_pagination(records, paginator, order_options)
-        end
-
-        records
-      end
-
-      associated_records_method_name
-    end
-
-    def build_belongs_to(relationship, foreign_key, associated_records_method_name, relationship_name)
-      # Calls method matching foreign key name on model instance
-      define_on_resource foreign_key do
-        @model.method(foreign_key).call
-      end
-
-      # Returns instantiated related resource object or nil
-      define_on_resource relationship_name do |options = {}|
-        relationship = self.class._relationships[relationship_name]
-
-        if relationship.polymorphic?
-          associated_model = public_send(associated_records_method_name)
-          resource_klass = self.class.resource_for_model(associated_model) if associated_model
-          return resource_klass.new(associated_model, @context) if resource_klass
-        else
-          resource_klass = relationship.resource_klass
-          if resource_klass
-            associated_model = public_send(associated_records_method_name)
-            return associated_model ? resource_klass.new(associated_model, @context) : nil
-          end
-        end
-      end
-    end
-
-    def build_has_one(relationship, foreign_key, associated_records_method_name, relationship_name)
-      # Returns primary key name of related resource class
-      define_on_resource foreign_key do
-        relationship = self.class._relationships[relationship_name]
-
-        record = public_send(associated_records_method_name)
-        return nil if record.nil?
-        record.public_send(relationship.resource_klass._primary_key)
-      end
-
-      # Returns instantiated related resource object or nil
-      define_on_resource relationship_name do |options = {}|
-        relationship = self.class._relationships[relationship_name]
-
-        if relationship.polymorphic?
-          associated_model = public_send(associated_records_method_name)
-          resource_klass = self.class.resource_for_model(associated_model) if associated_model
-          return resource_klass.new(associated_model, @context) if resource_klass && associated_model
-        else
-          resource_klass = relationship.resource_klass
-          if resource_klass
-            associated_model = public_send(associated_records_method_name)
-            return associated_model ? resource_klass.new(associated_model, @context) : nil
-          end
-        end
-      end
-    end
-
-    def build_to_many(relationship, foreign_key, associated_records_method_name, relationship_name)
-      # Returns array of primary keys of related resource classes
-      define_on_resource foreign_key do
-        records = public_send(associated_records_method_name)
-        return records.collect do |record|
-          record.public_send(relationship.resource_klass._primary_key)
-        end
-      end
-
-      # Returns array of instantiated related resource objects
-      define_on_resource relationship_name do |options = {}|
-        relationship = self.class._relationships[relationship_name]
-
-        resource_klass = relationship.resource_klass
-        records = public_send(associated_records_method_name, options)
-
-        return records.collect do |record|
-          if relationship.polymorphic?
-            resource_klass = self.class.resource_for_model(record)
-          end
-          resource_klass.new(record, @context)
-        end
-      end
-    end
-
-    def define_on_resource(method_name, &block)
-      return if @resource_class.method_defined?(method_name)
-      @resource_class.inject_method_definition(method_name, block)
-    end
-  end
-end