jsonapi-resources 0.7.1.beta1 → 0.7.1.beta2

data/lib/jsonapi/formatter.rb

@@ -9,9 +9,12 @@ module JSONAPI
         arg
       end
 
+      def cached
+        return FormatterWrapperCache.new(self)
+      end
+
       def formatter_for(format)
-        formatter_class_name = "#{format.to_s.camelize}Formatter"
-        formatter_class_name.safe_constantize
+        "#{format.to_s.camelize}Formatter".safe_constantize
       end
     end
   end
@@ -51,11 +54,33 @@ module JSONAPI
       end
 
       def value_formatter_for(type)
-        formatter_name = "#{type.to_s.camelize}Value"
-        formatter_for(formatter_name)
+        "#{type.to_s.camelize}ValueFormatter".safe_constantize
       end
     end
   end
+
+  # Warning: Not thread-safe. Wrap in ThreadLocalVar as needed.
+  class FormatterWrapperCache
+    attr_reader :formatter_klass
+
+    def initialize(formatter_klass)
+      @formatter_klass = formatter_klass
+      @format_cache = NaiveCache.new{|arg| formatter_klass.format(arg) }
+      @unformat_cache = NaiveCache.new{|arg| formatter_klass.unformat(arg) }
+    end
+
+    def format(arg)
+      @format_cache.get(arg)
+    end
+
+    def unformat(arg)
+      @unformat_cache.get(arg)
+    end
+
+    def cached
+      self
+    end
+  end
 end
 
 class UnderscoredKeyFormatter < JSONAPI::KeyFormatter

data/lib/jsonapi/link_builder.rb

@@ -2,21 +2,24 @@ module JSONAPI
   class LinkBuilder
     attr_reader :base_url,
                 :primary_resource_klass,
-                :route_formatter
+                :route_formatter,
+                :engine_name
 
     def initialize(config = {})
       @base_url               = config[:base_url]
       @primary_resource_klass = config[:primary_resource_klass]
       @route_formatter        = config[:route_formatter]
-      @is_engine              = !!engine_name
-    end
+      @engine_name            = build_engine_name
 
-    def engine?
-      @is_engine
+      # Warning: These make LinkBuilder non-thread-safe. That's not a problem with the
+      # request-specific way it's currently used, though.
+      @resources_path_cache   = JSONAPI::NaiveCache.new do |source_klass|
+        formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
+      end
     end
 
-    def engine_name
-      @engine_name ||= build_engine_name
+    def engine?
+      !!@engine_name
     end
 
     def primary_resources_url
@@ -96,14 +99,14 @@ module JSONAPI
     end
 
     def format_route(route)
-      route_formatter.format(route.to_s)
+      route_formatter.format(route)
     end
 
     def formatted_module_path_from_class(klass)
       scopes = module_scopes_from_class(klass)
 
       unless scopes.empty?
-        "/#{ scopes.map(&:underscore).join('/') }/"
+        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.join('/') }/"
       else
         "/"
       end
@@ -113,11 +116,12 @@ module JSONAPI
       klass.name.to_s.split("::")[0...-1]
     end
 
+    def regular_resources_path(source_klass)
+      @resources_path_cache.get(source_klass)
+    end
+
     def regular_primary_resources_path
-      [
-        formatted_module_path_from_class(primary_resource_klass),
-        format_route(primary_resource_klass._type.to_s),
-      ].join
+      regular_resources_path(primary_resource_klass)
     end
 
     def regular_primary_resources_url
@@ -125,11 +129,7 @@ module JSONAPI
     end
 
     def regular_resource_path(source)
-      [
-        formatted_module_path_from_class(source.class),
-        format_route(source.class._type.to_s),
-        "/#{ source.id }",
-      ].join
+      "#{regular_resources_path(source.class)}/#{source.id}"
     end
 
     def regular_resource_url(source)

data/lib/jsonapi/mime_types.rb

@@ -1,11 +1,30 @@
 module JSONAPI
   MEDIA_TYPE = 'application/vnd.api+json'
-end
 
-Mime::Type.register JSONAPI::MEDIA_TYPE, :api_json
+  module MimeTypes
+    def self.install
+      Mime::Type.register JSONAPI::MEDIA_TYPE, :api_json
+
+      # :nocov:
+      if Rails::VERSION::MAJOR >= 5
+        parsers = ActionDispatch::Request.parameter_parsers.merge(
+          Mime::Type.lookup(JSONAPI::MEDIA_TYPE).symbol => parser
+        )
+        ActionDispatch::Request.parameter_parsers = parsers
+      else
+        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(JSONAPI::MEDIA_TYPE)] = parser
+      end
+      # :nocov:
+    end
+
+    def self.parser
+      lambda do |body|
+        data = JSON.parse(body)
+        data = {:_json => data} unless data.is_a?(Hash)
+        data.with_indifferent_access
+      end
+    end
+  end
 
-ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(JSONAPI::MEDIA_TYPE)] = lambda do |body|
-  data = JSON.parse(body)
-  data = {:_json => data} unless data.is_a?(Hash)
-  data.with_indifferent_access
+  MimeTypes.install
 end

data/lib/jsonapi/naive_cache.rb

@@ -0,0 +1,30 @@
+module JSONAPI
+
+  # Cache which memoizes the given block.
+  #
+  # It's "naive" because it clears the least-recently-inserted cache entry
+  # rather than the least-recently-used. This makes lookups faster but cache
+  # misses more frequent after cleanups. Therefore you the best time to use
+  # this cache is when you expect only a small number of unique lookup keys, so
+  # that the cache never has to clear.
+  #
+  # Also, it's not thread safe (although jsonapi-resources is careful to only
+  # use it in a thread safe way).
+  class NaiveCache
+    def initialize(cap = 10000, &calculator)
+      @cap = cap
+      @data = {}
+      @calculator = calculator
+    end
+
+    def get(key)
+      found = true
+      value = @data.fetch(key) { found = false }
+      return value if found
+      value = @calculator.call(key)
+      @data[key] = value
+      @data.shift if @data.length > @cap
+      return value
+    end
+  end
+end

data/lib/jsonapi/operation.rb

@@ -1,356 +1,24 @@
 module JSONAPI
   class Operation
-    attr_reader :resource_klass, :options, :transactional
+    attr_reader :resource_klass, :operation_type, :options
 
-    def initialize(resource_klass, options = {})
-      @context = options[:context]
+    def initialize(operation_type, resource_klass, options)
+      @operation_type = operation_type
       @resource_klass = resource_klass
       @options = options
-      @transactional = true
     end
 
-    def apply
+    def transactional?
+      JSONAPI::Processor._processor_from_resource_type(resource_klass).transactional_operation_type?(operation_type)
     end
-  end
-
-  class FindOperation < Operation
-    attr_reader :filters, :include_directives, :sort_criteria, :paginator
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @filters = options[:filters]
-      @include_directives = options[:include_directives]
-      @sort_criteria = options.fetch(:sort_criteria, [])
-      @paginator = options[:paginator]
-      @transactional = false
-    end
-
-    def record_count
-      @_record_count ||= @resource_klass.find_count(@resource_klass.verify_filters(@filters, @context),
-                                                    context: @context,
-                                                    include_directives: @include_directives)
-    end
-
-    def pagination_params
-      if @paginator && JSONAPI.configuration.top_level_links_include_pagination
-        options = {}
-        options[:record_count] = record_count if @paginator.class.requires_record_count
-        return @paginator.links_page_params(options)
-      else
-        return {}
-      end
-    end
-
-    def apply
-      resource_records = @resource_klass.find(@resource_klass.verify_filters(@filters, @context),
-                                              context: @context,
-                                              include_directives: @include_directives,
-                                              sort_criteria: @sort_criteria,
-                                              paginator: @paginator)
-
-      options = {}
-      if JSONAPI.configuration.top_level_links_include_pagination
-        options[:pagination_params] = pagination_params
-      end
-
-      if JSONAPI.configuration.top_level_meta_include_record_count
-        options[:record_count] = record_count
-      end
-
-      return JSONAPI::ResourcesOperationResult.new(:ok,
-                                                   resource_records,
-                                                   options)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class ShowOperation < Operation
-    attr_reader :id, :include_directives
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @id = options.fetch(:id)
-      @include_directives = options[:include_directives]
-      @transactional = false
-    end
-
-    def apply
-      key = @resource_klass.verify_key(@id, @context)
-
-      resource_record = @resource_klass.find_by_key(key,
-                                                    context: @context,
-                                                    include_directives: @include_directives)
-
-      return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class ShowRelationshipOperation < Operation
-    attr_reader :parent_key, :relationship_type
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @parent_key = options.fetch(:parent_key)
-      @relationship_type = options.fetch(:relationship_type)
-      @transactional = false
-    end
-
-    def apply
-      parent_resource = resource_klass.find_by_key(@parent_key, context: @context)
-
-      return JSONAPI::LinksObjectOperationResult.new(:ok,
-                                                     parent_resource,
-                                                     resource_klass._relationship(@relationship_type))
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class ShowRelatedResourceOperation < Operation
-    attr_reader :source_klass, :source_id, :relationship_type
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @source_klass = options.fetch(:source_klass)
-      @source_id = options.fetch(:source_id)
-      @relationship_type = options.fetch(:relationship_type)
-      @transactional = false
-    end
-
-    def apply
-      source_resource = @source_klass.find_by_key(@source_id, context: @context)
-
-      related_resource = source_resource.public_send(@relationship_type)
-
-      return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class ShowRelatedResourcesOperation < Operation
-    attr_reader :source_klass, :source_id, :relationship_type, :filters, :sort_criteria, :paginator
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @source_klass = options.fetch(:source_klass)
-      @source_id = options.fetch(:source_id)
-      @relationship_type = options.fetch(:relationship_type)
-      @filters = options[:filters]
-      @sort_criteria = options[:sort_criteria]
-      @paginator = options[:paginator]
-      @transactional = false
-    end
-
-    def record_count
-      @_record_count ||= records.count(:all)
-    end
-
-    def source_resource
-      @_source_resource ||= @source_klass.find_by_key(@source_id, context: @context)
-    end
-
-    def records
-      related_resource_records = source_resource.public_send("records_for_" + @relationship_type)
-      @resource_klass.filter_records(@filters, @options, related_resource_records)
-    end
-
-    def pagination_params
-      if @paginator && JSONAPI.configuration.top_level_links_include_pagination
-        options = {}
-        options[:record_count] = record_count if @paginator.class.requires_record_count
-        @paginator.links_page_params(options)
-      else
-        {}
-      end
-    end
-
-    def options
-      opts = {}
-      opts.merge!(pagination_params: pagination_params) if JSONAPI.configuration.top_level_links_include_pagination
-      opts.merge!(record_count: record_count) if JSONAPI.configuration.top_level_meta_include_record_count
-      opts
-    end
-
-    def apply
-      related_resource = source_resource.public_send(@relationship_type,
-                                              filters:  @filters,
-                                              sort_criteria: @sort_criteria,
-                                              paginator: @paginator)
-
-      return JSONAPI::RelatedResourcesOperationResult.new(:ok, source_resource, @relationship_type, related_resource, options)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
 
-  class CreateResourceOperation < Operation
-    attr_reader :data
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @data = options.fetch(:data)
-    end
-
-    def apply
-      resource = @resource_klass.create(@context)
-      result = resource.replace_fields(@data)
-
-      return JSONAPI::ResourceOperationResult.new((result == :completed ? :created : :accepted), resource)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class RemoveResourceOperation < Operation
-    attr_reader :resource_id
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.remove
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
-    end
-  end
-
-  class ReplaceFieldsOperation < Operation
-    attr_reader :data, :resource_id
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @data = options.fetch(:data)
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_fields(data)
-
-      return JSONAPI::ResourceOperationResult.new(result == :completed ? :ok : :accepted, resource)
-    end
-  end
-
-  class ReplaceToOneRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type, :key_value
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @key_value = options.fetch(:key_value)
-      @relationship_type = options.fetch(:relationship_type).to_sym
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_to_one_link(@relationship_type, @key_value)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-    end
-  end
-
-  class ReplacePolymorphicToOneRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type, :key_value, :key_type
-
-    def initialize(resource_klass, options = {})
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @key_value = options.fetch(:key_value)
-      @key_type = options.fetch(:key_type)
-      @relationship_type = options.fetch(:relationship_type).to_sym
+    def process
+      processor.process
     end
 
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_polymorphic_to_one_link(@relationship_type, @key_value, @key_type)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-    end
-  end
-
-  class CreateToManyRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type, :data
-
-    def initialize(resource_klass, options)
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @data = options.fetch(:data)
-      @relationship_type = options.fetch(:relationship_type).to_sym
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.create_to_many_links(@relationship_type, @data)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-    end
-  end
-
-  class ReplaceToManyRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type, :data
-
-    def initialize(resource_klass, options)
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @data = options.fetch(:data)
-      @relationship_type = options.fetch(:relationship_type).to_sym
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_to_many_links(@relationship_type, @data)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-    end
-  end
-
-  class RemoveToManyRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type, :associated_key
-
-    def initialize(resource_klass, options)
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @associated_key = options.fetch(:associated_key)
-      @relationship_type = options.fetch(:relationship_type).to_sym
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.remove_to_many_link(@relationship_type, @associated_key)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
-    end
-  end
-
-  class RemoveToOneRelationshipOperation < Operation
-    attr_reader :resource_id, :relationship_type
-
-    def initialize(resource_klass, options)
-      super(resource_klass, options)
-      @resource_id = options.fetch(:resource_id)
-      @relationship_type = options.fetch(:relationship_type).to_sym
-    end
-
-    def apply
-      resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.remove_to_one_link(@relationship_type)
-
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
+    private
+    def processor
+      JSONAPI::Processor.processor_instance_for(resource_klass, operation_type, options)
     end
   end
 end