jsonapi-resources 0.0.4 → 0.0.5

data/lib/jsonapi/formatter.rb

@@ -0,0 +1,94 @@
+module JSONAPI
+  class Formatter
+    class << self
+      def format(arg)
+        arg.to_s
+      end
+
+      def unformat(arg)
+        arg
+      end
+
+      if RUBY_VERSION >= '2.0'
+        def formatter_for(format)
+          formatter_class_name = "#{format.to_s.camelize}Formatter"
+          Object.const_get formatter_class_name if formatter_class_name
+        end
+      else
+        def formatter_for(format)
+          formatter_class_name = "#{format.to_s.camelize}Formatter"
+          formatter_class_name.safe_constantize if formatter_class_name
+        end
+      end
+    end
+  end
+
+  class KeyFormatter < Formatter
+    class << self
+      def format(key)
+        super
+      end
+
+      def unformat(formatted_key)
+        super.to_sym
+      end
+    end
+  end
+
+  class ValueFormatter < Formatter
+    class << self
+      def format(raw_value, source, context)
+        super(raw_value)
+      end
+
+      def unformat(value, resource_klass, context)
+        super(value)
+      end
+
+      def value_formatter_for(type)
+        formatter_name = "#{type.to_s.camelize}Value"
+        formatter_for(formatter_name)
+      end
+    end
+  end
+end
+
+class UnderscoredKeyFormatter < JSONAPI::KeyFormatter
+end
+
+class CamelizedKeyFormatter < JSONAPI::KeyFormatter
+  class << self
+    def format(key)
+      super.camelize(:lower)
+    end
+
+    def unformat(formatted_key)
+      formatted_key.to_s.underscore.to_sym
+    end
+  end
+end
+
+class DasherizedKeyFormatter < JSONAPI::KeyFormatter
+  class << self
+    def format(key)
+      super.dasherize
+    end
+
+    def unformat(formatted_key)
+      formatted_key.to_s.underscore.to_sym
+    end
+  end
+end
+
+class DefaultValueFormatter < JSONAPI::ValueFormatter
+  class << self
+    def format(raw_value, source, context)
+      case raw_value
+        when String, Integer
+          return raw_value
+        else
+          return raw_value.to_s
+      end
+    end
+  end
+end

data/lib/jsonapi/operation.rb

@@ -67,9 +67,25 @@ module JSONAPI
       resource.save(context)
 
       return JSONAPI::OperationResult.new(:ok, resource)
+    end
+  end
 
-    rescue JSONAPI::Exceptions::Error => e
-      return JSONAPI::OperationResult.new(e.errors.count == 1 ? e.errors[0].code : :bad_request, nil, e.errors)
+  class CreateHasOneAssociationOperation < Operation
+    attr_reader :resource_id, :association_type, :key_value
+
+    def initialize(resource_klass, resource_id, association_type, key_value)
+      @resource_id = resource_id
+      @key_value = key_value
+      @association_type = association_type.to_sym
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.create_has_one_link(@association_type, @key_value, context)
+      resource.save(context)
+
+      return JSONAPI::OperationResult.new(:no_content)
     end
   end
 
@@ -79,7 +95,7 @@ module JSONAPI
     def initialize(resource_klass, resource_id, association_type, key_value)
       @resource_id = resource_id
       @key_value = key_value
-      @association_type = association_type
+      @association_type = association_type.to_sym
       super(resource_klass)
     end
 
@@ -88,7 +104,7 @@ module JSONAPI
       resource.replace_has_one_link(@association_type, @key_value, context)
       resource.save(context)
 
-      return JSONAPI::OperationResult.new(:created, resource)
+      return JSONAPI::OperationResult.new(:no_content)
     end
   end
 
@@ -98,7 +114,7 @@ module JSONAPI
     def initialize(resource_klass, resource_id, association_type, key_values)
       @resource_id = resource_id
       @key_values = key_values
-      @association_type = association_type
+      @association_type = association_type.to_sym
       super(resource_klass)
     end
 
@@ -108,7 +124,26 @@ module JSONAPI
         resource.create_has_many_link(@association_type, value, context)
       end
 
-      return JSONAPI::OperationResult.new(:created, resource)
+      return JSONAPI::OperationResult.new(:no_content)
+    end
+  end
+
+  class ReplaceHasManyAssociationOperation < Operation
+    attr_reader :resource_id, :association_type, :key_values
+
+    def initialize(resource_klass, resource_id, association_type, key_values)
+      @resource_id = resource_id
+      @key_values = key_values
+      @association_type = association_type.to_sym
+      super(resource_klass)
+    end
+
+    def apply(context)
+      resource = @resource_klass.find_by_key(@resource_id, context)
+      resource.replace_has_many_links(@association_type, @key_values, context)
+      resource.save(context)
+
+      return JSONAPI::OperationResult.new(:no_content)
     end
   end
 
@@ -118,7 +153,7 @@ module JSONAPI
     def initialize(resource_klass, resource_id, association_type, associated_key)
       @resource_id = resource_id
       @associated_key = associated_key
-      @association_type = association_type
+      @association_type = association_type.to_sym
       super(resource_klass)
     end
 
@@ -127,8 +162,10 @@ module JSONAPI
       resource.remove_has_many_link(@association_type, @associated_key, context)
 
       return JSONAPI::OperationResult.new(:no_content)
-    end
 
+    rescue ActiveRecord::RecordNotFound => e
+      raise JSONAPI::Exceptions::RecordNotFound.new(@associated_key)
+    end
   end
 
   class RemoveHasOneAssociationOperation < Operation
@@ -136,7 +173,7 @@ module JSONAPI
 
     def initialize(resource_klass, resource_id, association_type)
       @resource_id = resource_id
-      @association_type = association_type
+      @association_type = association_type.to_sym
       super(resource_klass)
     end
 

data/lib/jsonapi/request.rb

@@ -5,14 +5,15 @@ module JSONAPI
   class Request
     include ResourceFor
 
-    attr_accessor :fields, :includes, :filters, :errors, :operations, :resource_klass, :context
+    attr_accessor :fields, :include, :filters, :errors, :operations, :resource_klass, :context
 
-    def initialize(context = nil, params = nil)
-      @context = context
+    def initialize(params = nil, options = {})
+      @context = options.fetch(:context, nil)
+      @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
       @errors = []
       @operations = []
       @fields = {}
-      @includes = []
+      @include = []
       @filters = {}
 
       setup(params) if params
@@ -25,23 +26,23 @@ module JSONAPI
         case params[:action]
           when 'index'
             parse_fields(params)
-            parse_includes(params)
+            parse_include(params)
             parse_filters(params)
           when 'show_associations'
           when 'show'
             parse_fields(params)
-            parse_includes(params)
+            parse_include(params)
           when 'create'
             parse_fields(params)
-            parse_includes(params)
+            parse_include(params)
             parse_add_operation(params)
           when 'create_association'
-            parse_fields(params)
-            parse_includes(params)
             parse_add_association_operation(params)
+          when 'update_association'
+            parse_update_association_operation(params)
           when 'update'
             parse_fields(params)
-            parse_includes(params)
+            parse_include(params)
             parse_replace_operation(params)
           when 'destroy'
             parse_remove_operation(params)
@@ -58,13 +59,13 @@ module JSONAPI
       unless params[:fields].nil?
         if params[:fields].is_a?(String)
           value = params[:fields]
-          resource_fields = value.split(',').map {|s| s.to_sym } unless value.nil? || value.empty?
-          type = @resource_klass._serialize_as
+          resource_fields = value.split(',') unless value.nil? || value.empty?
+          type = @resource_klass._type
           fields[type] = resource_fields
         elsif params[:fields].is_a?(ActionController::Parameters)
           params[:fields].each do |param, value|
-            resource_fields = value.split(',').map {|s| s.to_sym } unless value.nil? || value.empty?
-            type = param.to_sym
+            resource_fields = value.split(',') unless value.nil? || value.empty?
+            type = param
             fields[type] = resource_fields
           end
         end
@@ -72,15 +73,18 @@ module JSONAPI
 
       # Validate the fields
       fields.each do |type, values|
+        underscored_type = unformat_key(type)
         fields[type] = []
-        type_resource = self.class.resource_for(type)
-        if type_resource.nil? || !(@resource_klass._type == type || @resource_klass._has_association?(type))
+        type_resource = self.class.resource_for(underscored_type)
+        if type_resource.nil? || !(@resource_klass._type == underscored_type ||
+                                   @resource_klass._has_association?(underscored_type))
           @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
         else
           unless values.nil?
+            valid_fields = type_resource.fields.collect {|key| format_key(key)}
             values.each do |field|
-              if type_resource._validate_field(field)
-                fields[type].push field
+              if valid_fields.include?(field)
+                fields[type].push unformat_key(field)
               else
                 @errors.concat(JSONAPI::Exceptions::InvalidField.new(type, field).errors)
               end
@@ -91,14 +95,31 @@ module JSONAPI
         end
       end
 
-      @fields = fields
+      @fields = fields.deep_transform_keys{ |key| unformat_key(key) }
+    end
+
+    def check_include(resource_klass, include_parts)
+      association_name = unformat_key(include_parts.first)
+
+      association = resource_klass._association(association_name)
+      if association
+        unless include_parts.last.empty?
+          check_include(Resource.resource_for(association.class_name), include_parts.last.partition('.'))
+        end
+      else
+        @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
+                                                               include_parts.first, ).errors)
+      end
     end
 
-    def parse_includes(params)
-      includes = params[:include]
-      included_resources = []
-      included_resources += CSV.parse_line(includes) unless includes.nil? || includes.empty?
-      @includes = included_resources
+    def parse_include(params)
+      included_resources_raw = CSV.parse_line(params[:include]) unless params[:include].nil? || params[:include].empty?
+      @include = []
+      return if included_resources_raw.nil?
+      included_resources_raw.each do |include|
+        check_include(@resource_klass, include.partition('.'))
+        @include.push(unformat_key(include).to_s)
+      end
     end
 
     def parse_filters(params)
@@ -124,17 +145,16 @@ module JSONAPI
     end
 
     def parse_add_operation(params)
-      object_params_raw = params.require(@resource_klass._type)
+      object_params_raw = params.require(format_key(@resource_klass._type))
 
       if object_params_raw.is_a?(Array)
         object_params_raw.each do |p|
           @operations.push JSONAPI::CreateResourceOperation.new(@resource_klass,
-                                                                  @resource_klass.verify_create_params(p, @context))
+                                                                parse_params(p, @resource_klass.createable_fields(@context)))
         end
       else
         @operations.push JSONAPI::CreateResourceOperation.new(@resource_klass,
-                                                                @resource_klass.verify_create_params(object_params_raw,
-                                                                                                     @context))
+                                                              parse_params(object_params_raw, @resource_klass.createable_fields(@context)))
       end
     rescue ActionController::ParameterMissing => e
       @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
@@ -142,37 +162,141 @@ module JSONAPI
       @errors.concat(e.errors)
     end
 
+    def parse_params(params, allowed_fields)
+      # push links into top level param list with attributes in order to check for invalid params
+      if params[:links]
+        params[:links].each do |link, value|
+          params[link] = value
+        end
+        params.delete(:links)
+      end
+      verify_permitted_params(params, allowed_fields)
+
+      checked_attributes = {}
+      checked_has_one_associations = {}
+      checked_has_many_associations = {}
+
+      params.each do |key, value|
+        param = unformat_key(key)
+
+        association = @resource_klass._association(param)
+
+        if association.is_a?(JSONAPI::Association::HasOne)
+          checked_has_one_associations[param] = @resource_klass.resource_for(association.type).verify_key(value, context)
+        elsif association.is_a?(JSONAPI::Association::HasMany)
+          keys = []
+          if value.is_a?(Array)
+            value.each do |val|
+              keys.push(@resource_klass.resource_for(association.type).verify_key(val, context))
+            end
+          else
+            keys.push(@resource_klass.resource_for(association.type).verify_key(value, context))
+          end
+          checked_has_many_associations[param] = keys
+        else
+          checked_attributes[param] = unformat_value(param, value)
+        end
+      end
+
+      return {
+        'attributes' => checked_attributes,
+        'has_one' => checked_has_one_associations,
+        'has_many' => checked_has_many_associations
+      }.deep_transform_keys{ |key| unformat_key(key) }
+    end
+
+    def unformat_value(attribute, value)
+      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(@resource_klass._attribute_options(attribute)[:format])
+      value_formatter.unformat(value, @resource_klass, context)
+    end
+
+    def verify_permitted_params(params, allowed_fields)
+      formatted_allowed_fields = allowed_fields.collect {|field| format_key(field).to_sym}
+      params_not_allowed = []
+      params.keys.each do |key|
+        params_not_allowed.push(key) unless formatted_allowed_fields.include?(key.to_sym)
+      end
+      raise JSONAPI::Exceptions::ParametersNotAllowed.new(params_not_allowed) if params_not_allowed.length > 0
+    end
+
     def parse_add_association_operation(params)
-      association_type = params[:association].to_sym
+      association_type = params[:association]
 
       parent_key = params[resource_klass._as_parent_key]
 
-      if params[association_type].nil?
-        raise ActionController::ParameterMissing.new(association_type)
+      association = resource_klass._association(association_type)
+
+      if association.is_a?(JSONAPI::Association::HasOne)
+        plural_association_type = association_type.pluralize
+
+        if params[plural_association_type].nil?
+          raise ActionController::ParameterMissing.new(plural_association_type)
+        end
+
+        object_params = {links: {association_type => params[plural_association_type]}}
+        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
+
+        @operations.push JSONAPI::CreateHasOneAssociationOperation.new(resource_klass,
+                                                                      parent_key,
+                                                                      association_type,
+                                                                      verified_param_set[:has_one].values[0])
+      else
+        if params[association_type].nil?
+          raise ActionController::ParameterMissing.new(association_type)
+        end
+
+        object_params = {links: {association_type => params[association_type]}}
+        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
+
+        @operations.push JSONAPI::CreateHasManyAssociationOperation.new(resource_klass,
+                                                                        parent_key,
+                                                                        association_type,
+                                                                        verified_param_set[:has_many].values[0])
       end
+    rescue ActionController::ParameterMissing => e
+      @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
+    end
 
-      object_params = {links: {association_type => params[association_type]}}
-      verified_param_set = @resource_klass.verify_update_params(object_params, @context)
+    def parse_update_association_operation(params)
+      association_type = params[:association]
+
+      parent_key = params[resource_klass._as_parent_key]
 
       association = resource_klass._association(association_type)
 
       if association.is_a?(JSONAPI::Association::HasOne)
+        plural_association_type = association_type.pluralize
+
+        if params[plural_association_type].nil?
+          raise ActionController::ParameterMissing.new(plural_association_type)
+        end
+
+        object_params = {links: {association_type => params[plural_association_type]}}
+        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
+
         @operations.push JSONAPI::ReplaceHasOneAssociationOperation.new(resource_klass,
-                                                                          parent_key,
-                                                                          association_type,
-                                                                          verified_param_set[:has_one].values[0])
+                                                                        parent_key,
+                                                                        association_type,
+                                                                        verified_param_set[:has_one].values[0])
       else
-        @operations.push JSONAPI::CreateHasManyAssociationOperation.new(resource_klass,
-                                                                          parent_key,
-                                                                          association_type,
-                                                                          verified_param_set[:has_many].values[0])
+        if params[association_type].nil?
+          raise ActionController::ParameterMissing.new(association_type)
+        end
+
+        object_params = {links: {association_type => params[association_type]}}
+        verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
+
+        @operations.push JSONAPI::ReplaceHasManyAssociationOperation.new(resource_klass,
+                                                                         parent_key,
+                                                                         association_type,
+                                                                         verified_param_set[:has_many].values[0])
       end
     rescue ActionController::ParameterMissing => e
       @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
     end
 
     def parse_replace_operation(params)
-      object_params_raw = params.require(@resource_klass._type)
+      object_params_raw = params.require(format_key(@resource_klass._type))
 
       keys = params[@resource_klass._key]
       if object_params_raw.is_a?(Array)
@@ -189,9 +313,8 @@ module JSONAPI
             raise JSONAPI::Exceptions::KeyNotIncludedInURL.new(object_params[@resource_klass._key])
           end
           @operations.push JSONAPI::ReplaceFieldsOperation.new(@resource_klass,
-                                                                 object_params[@resource_klass._key],
-                                                                 @resource_klass.verify_update_params(object_params,
-                                                                                                      @context))
+                                                               object_params[@resource_klass._key],
+                                                               parse_params(object_params, @resource_klass.updateable_fields(@context)))
         end
       else
         if !object_params_raw[@resource_klass._key].nil? && keys != object_params_raw[@resource_klass._key]
@@ -200,8 +323,7 @@ module JSONAPI
 
         @operations.push JSONAPI::ReplaceFieldsOperation.new(@resource_klass,
                                                                params[@resource_klass._key],
-                                                               @resource_klass.verify_update_params(object_params_raw,
-                                                                                                    @context))
+                                                               parse_params(object_params_raw, @resource_klass.updateable_fields(@context)))
       end
 
     rescue ActionController::ParameterMissing => e
@@ -223,7 +345,7 @@ module JSONAPI
     end
 
     def parse_remove_association_operation(params)
-      association_type = params[:association].to_sym
+      association_type = params[:association]
 
       parent_key = params[resource_klass._as_parent_key]
 
@@ -250,5 +372,13 @@ module JSONAPI
       end
       return keys
     end
+
+    def format_key(key)
+      @key_formatter.format(key)
+    end
+
+    def unformat_key(key)
+      @key_formatter.unformat(key)
+    end
   end
-end
+end