jsonapi-resources 0.3.3 → 0.4.0

data/jsonapi-resources.gemspec

@@ -25,5 +25,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-spec-rails'
   spec.add_development_dependency 'minitest-reporters'
   spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'pry'
   spec.add_dependency 'rails', '>= 4.0'
 end

data/lib/jsonapi-resources.rb

@@ -1,4 +1,6 @@
 require 'jsonapi/resource'
+require 'jsonapi/response_document'
+require 'jsonapi/acts_as_resource_controller'
 require 'jsonapi/resource_controller'
 require 'jsonapi/resources/version'
 require 'jsonapi/configuration'
@@ -6,3 +8,16 @@ require 'jsonapi/paginator'
 require 'jsonapi/formatter'
 require 'jsonapi/routing_ext'
 require 'jsonapi/mime_types'
+require 'jsonapi/resource_serializer'
+require 'jsonapi/exceptions'
+require 'jsonapi/error'
+require 'jsonapi/error_codes'
+require 'jsonapi/request'
+require 'jsonapi/operations_processor'
+require 'jsonapi/active_record_operations_processor'
+require 'jsonapi/association'
+require 'jsonapi/include_directives'
+require 'jsonapi/operation_result'
+require 'jsonapi/operation_results'
+require 'jsonapi/callbacks'
+

data/lib/jsonapi/active_record_operations_processor.rb

@@ -1,17 +1,28 @@
-require 'jsonapi/operations_processor'
+class ActiveRecordOperationsProcessor < JSONAPI::OperationsProcessor
 
-module JSONAPI
-  class ActiveRecordOperationsProcessor < OperationsProcessor
-
-    private
-    def transaction
+  private
+  def transaction
+    if @transactional
       ActiveRecord::Base.transaction do
         yield
       end
+    else
+      yield
     end
+  end
 
-    def rollback
-      raise ActiveRecord::Rollback
-    end
+  def rollback
+    raise ActiveRecord::Rollback if @transactional
+  end
+
+  def process_operation(operation)
+    operation.apply(@context)
+  rescue ActiveRecord::DeleteRestrictionError => e
+    record_locked_error = JSONAPI::Exceptions::RecordLocked.new(e.message)
+    return JSONAPI::ErrorsOperationResult.new(record_locked_error.errors[0].code, record_locked_error.errors)
+
+  rescue ActiveRecord::RecordNotFound
+    record_not_found = JSONAPI::Exceptions::RecordNotFound.new(operation.associated_key)
+    return JSONAPI::ErrorsOperationResult.new(record_not_found.errors[0].code, record_not_found.errors)
   end
-end
+end

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -0,0 +1,175 @@
+require 'csv'
+
+module JSONAPI
+  module ActsAsResourceController
+    extend ActiveSupport::Concern
+
+    included do
+      before_filter :ensure_correct_media_type, only: [:create, :update, :create_association, :update_association]
+      before_filter :setup_request
+      after_filter :setup_response
+    end
+
+    def index
+      process_request_operations
+    end
+
+    def show
+      process_request_operations
+    end
+
+    def show_association
+      process_request_operations
+    end
+
+    def create
+      process_request_operations
+    end
+
+    def create_association
+      process_request_operations
+    end
+
+    def update_association
+      process_request_operations
+    end
+
+    def update
+      process_request_operations
+    end
+
+    def destroy
+      process_request_operations
+    end
+
+    def destroy_association
+      process_request_operations
+    end
+
+    def get_related_resource
+      process_request_operations
+    end
+
+    def get_related_resources
+      process_request_operations
+    end
+
+    # set the operations processor in the configuration or override this to use another operations processor
+    def create_operations_processor
+      JSONAPI.configuration.operations_processor.new
+    end
+
+    private
+    def resource_klass
+      @resource_klass ||= resource_klass_name.safe_constantize
+    end
+
+    def resource_serializer_klass
+      @resource_serializer_klass ||= JSONAPI::ResourceSerializer
+    end
+
+    def base_url
+      @base_url ||= request.protocol + request.host_with_port
+    end
+
+    def resource_klass_name
+      @resource_klass_name ||= "#{self.class.name.underscore.sub(/_controller$/, '').singularize}_resource".camelize
+    end
+
+    def ensure_correct_media_type
+      unless request.content_type == JSONAPI::MEDIA_TYPE
+        raise JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
+      end
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def setup_request
+      @request = JSONAPI::Request.new(params, {
+                                              context: context,
+                                              key_formatter: key_formatter
+                                            })
+      render_errors(@request.errors) unless @request.errors.empty?
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def setup_response
+      if response.body.size > 0
+        response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
+      end
+    end
+
+    # override to set context
+    def context
+      {}
+    end
+
+    # Control by setting in an initializer:
+    #     JSONAPI.configuration.json_key_format = :camelized_key
+    #     JSONAPI.configuration.route = :camelized_route
+    #
+    # Override if you want to set a per controller key format.
+    # Must return a class derived from KeyFormatter.
+    def key_formatter
+      JSONAPI.configuration.key_formatter
+    end
+
+    def route_formatter
+      JSONAPI.configuration.route_formatter
+    end
+
+    def base_response_meta
+      {}
+    end
+
+    def render_errors(errors)
+      operation_results = JSONAPI::OperationResults.new()
+      result = JSONAPI::ErrorsOperationResult.new(errors[0].status, errors)
+      operation_results.add_result(result)
+
+      render_results(operation_results)
+    end
+
+    def render_results(operation_results)
+      response_doc = create_response_document(operation_results)
+      render status: response_doc.status, json: response_doc.contents
+    end
+
+    def create_response_document(operation_results)
+      JSONAPI::ResponseDocument.new(
+        operation_results,
+        {
+          primary_resource_klass: resource_klass,
+          include_directives: @request ? @request.include_directives : nil,
+          fields: @request ? @request.fields : nil,
+          base_url: base_url,
+          key_formatter: key_formatter,
+          route_formatter: route_formatter,
+          base_meta: base_response_meta,
+          resource_serializer_klass: resource_serializer_klass
+        }
+      )
+    end
+
+    def process_request_operations
+      operation_results = create_operations_processor.process(@request)
+      render_results(operation_results)
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    # override this to process other exceptions
+    # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
+    def handle_exceptions(e)
+      case e
+        when JSONAPI::Exceptions::Error
+          render_errors(e.errors)
+        else # raise all other exceptions
+          # :nocov:
+          raise e
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/jsonapi/configuration.rb

@@ -1,4 +1,6 @@
 require 'jsonapi/formatter'
+require 'jsonapi/operations_processor'
+require 'jsonapi/active_record_operations_processor'
 
 module JSONAPI
   class Configuration
@@ -6,6 +8,7 @@ module JSONAPI
                 :key_formatter,
                 :route_format,
                 :route_formatter,
+                :operations_processor,
                 :allowed_request_params,
                 :default_paginator,
                 :default_page_size,
@@ -19,6 +22,9 @@ module JSONAPI
       #:underscored_route, :camelized_route, :dasherized_route, or custom
       self.route_format = :dasherized_route
 
+      #:basic, :active_record, or custom
+      self.operations_processor = :active_record
+
       self.allowed_request_params = [:include, :fields, :format, :controller, :action, :sort, :page]
 
       # :none, :offset, :paged, or a custom paginator name
@@ -39,6 +45,11 @@ module JSONAPI
       @route_formatter = JSONAPI::Formatter.formatter_for(format)
     end
 
+    def operations_processor=(operations_processor)
+      @operations_processor_name = operations_processor
+      @operations_processor = JSONAPI::OperationsProcessor.operations_processor_for(@operations_processor_name)
+    end
+
     def allowed_request_params=(allowed_request_params)
       @allowed_request_params = allowed_request_params
     end

data/lib/jsonapi/error_codes.rb

@@ -17,8 +17,9 @@ module JSONAPI
   TYPE_MISMATCH = 116
   INVALID_PAGE_OBJECT = 117
   INVALID_PAGE_VALUE = 118
-  INVALID_SORT_FORMAT = 119
-  INVALID_FIELD_FORMAT = 120
+  INVALID_FIELD_FORMAT = 119
+  INVALID_FILTERS_SYNTAX = 120
+  SAVE_FAILED = 121
   FORBIDDEN = 403
   RECORD_NOT_FOUND = 404
   UNSUPPORTED_MEDIA_TYPE = 415
@@ -43,10 +44,12 @@ module JSONAPI
       TYPE_MISMATCH => 'TYPE_MISMATCH',
       INVALID_PAGE_OBJECT => 'INVALID_PAGE_OBJECT',
       INVALID_PAGE_VALUE => 'INVALID_PAGE_VALUE',
-      INVALID_SORT_FORMAT => 'INVALID_SORT_FORMAT',
       INVALID_FIELD_FORMAT => 'INVALID_FIELD_FORMAT',
+      INVALID_FILTERS_SYNTAX => 'INVALID_FILTERS_SYNTAX',
+      SAVE_FAILED => 'SAVE_FAILED',
       FORBIDDEN => 'FORBIDDEN',
       RECORD_NOT_FOUND => 'RECORD_NOT_FOUND',
       UNSUPPORTED_MEDIA_TYPE => 'UNSUPPORTED_MEDIA_TYPE',
-      LOCKED => 'LOCKED' }
+      LOCKED => 'LOCKED'
+    }
 end

data/lib/jsonapi/exceptions.rb

@@ -67,6 +67,20 @@ module JSONAPI
       end
     end
 
+    class InvalidFiltersSyntax < Error
+      attr_accessor :filters
+      def initialize(filters)
+        @filters = filters
+      end
+
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_FILTERS_SYNTAX,
+                             status: :bad_request,
+                             title: 'Invalid filters syntax',
+                             detail: "#{filters} is not a valid syntax for filtering.")]
+      end
+    end
+
     class FilterNotAllowed < Error
       attr_accessor :filter
       def initialize(filter)
@@ -188,21 +202,6 @@ module JSONAPI
       end
     end
 
-    class InvalidSortFormat < Error
-      attr_accessor :sort_criteria, :resource
-      def initialize(resource, sort_criteria)
-        @resource = resource
-        @sort_criteria = sort_criteria
-      end
-
-      def errors
-        [JSONAPI::Error.new(code: JSONAPI::INVALID_SORT_FORMAT,
-                            status: :bad_request,
-                            title: 'Invalid sort format',
-                            detail: "#{sort_criteria} must start with a direction (+ or -)")]
-      end
-    end
-
     class ParametersNotAllowed < Error
       attr_accessor :params
       def initialize(params)
@@ -306,6 +305,15 @@ module JSONAPI
       end
     end
 
+    class SaveFailed < Error
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::SAVE_FAILED,
+                            status: :unprocessable_entity,
+                            title: 'Save failed or was cancelled',
+                            detail: 'Save failed or was cancelled')]
+      end
+    end
+
     class InvalidPageObject < Error
       def errors
         [JSONAPI::Error.new(code: JSONAPI::INVALID_PAGE_OBJECT,

data/lib/jsonapi/formatter.rb

@@ -11,7 +11,7 @@ module JSONAPI
 
       def formatter_for(format)
         formatter_class_name = "#{format.to_s.camelize}Formatter"
-        formatter_class_name.safe_constantize if formatter_class_name
+        formatter_class_name.safe_constantize
       end
     end
   end
@@ -42,11 +42,11 @@ module JSONAPI
 
   class ValueFormatter < Formatter
     class << self
-      def format(raw_value, context)
+      def format(raw_value)
         super(raw_value)
       end
 
-      def unformat(value, context)
+      def unformat(value)
         super(value)
       end
 
@@ -87,7 +87,7 @@ end
 
 class DefaultValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, context)
+    def format(raw_value)
       raw_value
     end
   end
@@ -95,7 +95,7 @@ end
 
 class IdValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, context)
+    def format(raw_value)
       return if raw_value.nil?
       raw_value.to_s
     end

data/lib/jsonapi/include_directives.rb

@@ -0,0 +1,67 @@
+module JSONAPI
+  class IncludeDirectives
+
+    # Construct an IncludeDirectives Hash from an array of dot separated include strings.
+    # For example ['posts.comments.tags']
+    # will transform into =>
+    # {
+    #   :posts=>{
+    #     :include=>true,
+    #     :include_related=>{
+    #       :comments=>{
+    #         :include=>true,
+    #         :include_related=>{
+    #           :tags=>{
+    #             :include=>true
+    #           }
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    def initialize(includes_array)
+      @include_directives_hash = {include_related: {}}
+      includes_array.each do |include|
+        parse_include(include)
+      end
+    end
+
+    def include_directives
+      @include_directives_hash
+    end
+
+    def model_includes
+      get_includes(@include_directives_hash)
+    end
+
+    private
+    def get_related(current_path)
+      current = @include_directives_hash
+      current_path.split('.').each do |fragment|
+        fragment = fragment.to_sym
+        current[:include_related][fragment] ||= {include: false, include_related: {}}
+        current = current[:include_related][fragment]
+      end
+      current
+    end
+
+    def get_includes(directive)
+      directive[:include_related].map do |name, directive|
+        sub = get_includes(directive)
+        sub.any? ? { name => sub } : name
+      end
+    end
+
+    def parse_include(include)
+      parts = include.split('.')
+      local_path = ''
+
+      parts.each do |name|
+        local_path += local_path.length > 0 ? ".#{name}" : name
+        related = get_related(local_path)
+        related[:include] = true
+      end
+    end
+  end
+end