jsonapi-resources 0.0.4 → 0.0.5

data/lib/jsonapi/resource.rb

@@ -1,3 +1,4 @@
+require 'jsonapi/configuration'
 require 'jsonapi/resource_for'
 require 'jsonapi/association'
 require 'action_dispatch/routing/mapper'
@@ -24,9 +25,15 @@ module JSONAPI
 
     def create_has_many_link(association_type, association_key_value, context)
       association = self.class._associations[association_type]
-      related_resource = self.class.resource_for(association.serialize_type_name).find_by_key(association_key_value, context)
+      related_resource = self.class.resource_for(association.type).find_by_key(association_key_value, context)
 
-      @object.send(association.serialize_type_name) << related_resource.object
+      # ToDo: Add option to skip relations that already exist instead of returning an error?
+      relation = @object.send(association.type).where(association.primary_key => association_key_value).first
+      if relation.nil?
+        @object.send(association.type) << related_resource.object
+      else
+        raise JSONAPI::Exceptions::HasManyRelationExists.new(association_key_value)
+      end
     end
 
     def replace_has_many_links(association_type, association_key_values, context)
@@ -35,6 +42,18 @@ module JSONAPI
       @object.send("#{association.key}=", association_key_values)
     end
 
+    def create_has_one_link(association_type, association_key_value, context)
+      association = self.class._associations[association_type]
+
+      # ToDo: Add option to skip relations that already exist instead of returning an error?
+      relation = @object.send("#{association.key}")
+      if relation.nil?
+        @object.send("#{association.key}=", association_key_value)
+      else
+        raise JSONAPI::Exceptions::HasOneRelationExists.new
+      end
+    end
+
     def replace_has_one_link(association_type, association_key_value, context)
       association = self.class._associations[association_type]
 
@@ -44,7 +63,7 @@ module JSONAPI
     def remove_has_many_link(association_type, key, context)
       association = self.class._associations[association_type]
 
-      @object.send(association.serialize_type_name).delete(key)
+      @object.send(association.type).delete(key)
     end
 
     def remove_has_one_link(association_type, context)
@@ -95,7 +114,7 @@ module JSONAPI
 
     class << self
       def inherited(base)
-        base._attributes = (_attributes || Set.new).dup
+        base._attributes = (_attributes || {}).dup
         base._associations = (_associations || {}).dup
         base._allowed_filters = (_allowed_filters || Set.new).dup
 
@@ -119,14 +138,13 @@ module JSONAPI
 
       # Methods used in defining a resource class
       def attributes(*attrs)
-        @_attributes.merge attrs
         attrs.each do |attr|
           attribute(attr)
         end
       end
 
-      def attribute(attr)
-        @_attributes.add attr
+      def attribute(attr, options = {})
+        @_attributes[attr] = options
         define_method attr do
           @object.send(attr)
         end unless method_defined?(attr)
@@ -136,6 +154,10 @@ module JSONAPI
         end unless method_defined?("#{attr}=")
       end
 
+      def default_attribute_options
+        {format: :default}
+      end
+
       def has_one(*attrs)
         _associate(Association::HasOne, *attrs)
       end
@@ -161,13 +183,17 @@ module JSONAPI
       end
 
       # Override in your resource to filter the updateable keys
-      def updateable(keys, context = nil)
-        keys
+      def updateable_fields(context)
+        fields
       end
 
       # Override in your resource to filter the createable keys
-      def createable(keys, context = nil)
-        keys
+      def createable_fields(context)
+        fields
+      end
+
+      def fields
+        _updateable_associations | _attributes.keys
       end
 
       # Override this method if you have more complex requirements than this basic find method provides
@@ -178,7 +204,7 @@ module JSONAPI
         filters.each do |filter, value|
           if _associations.include?(filter)
             if _associations[filter].is_a?(JSONAPI::Association::HasMany)
-              includes.push(filter.to_sym)
+              includes.push(filter)
               where_filters["#{filter}.#{_associations[filter].primary_key}"] = value
             else
               where_filters["#{_associations[filter].key}"] = value
@@ -204,53 +230,6 @@ module JSONAPI
         self.new(obj)
       end
 
-      def verify_create_params(object_params, context = nil)
-        verify_params(object_params, createable(_updateable_associations | _attributes.to_a), context)
-      end
-
-      def verify_update_params(object_params, context = nil)
-        verify_params(object_params, updateable(_updateable_associations | _attributes.to_a), context)
-      end
-
-      def verify_params(object_params, allowed_params, context)
-        # push links into top level param list with attributes in order to check for invalid params
-        if object_params[:links]
-          object_params[:links].each do |link, value|
-            object_params[link] = value
-          end
-          object_params.delete(:links)
-        end
-        verify_permitted_params(object_params, allowed_params)
-
-        checked_attributes = {}
-        checked_has_one_associations = {}
-        checked_has_many_associations = {}
-
-        object_params.each do |key, value|
-          param = key.to_sym
-
-          association = _associations[param]
-
-          if association.is_a?(JSONAPI::Association::HasOne)
-            checked_has_one_associations[param.to_sym] = resource_for(association.serialize_type_name).verify_key(value, context)
-          elsif association.is_a?(JSONAPI::Association::HasMany)
-            keys = []
-            value.each do |value|
-              keys.push(resource_for(association.serialize_type_name).verify_key(value, context))
-            end
-            checked_has_many_associations[param.to_sym] = keys
-          else
-            checked_attributes[param] = value
-          end
-        end
-
-        return {
-            attributes: checked_attributes,
-            has_one: checked_has_one_associations,
-            has_many: checked_has_many_associations
-        }
-      end
-
       def verify_filters(filters, context = nil)
         verified_filters = {}
         filters.each do |filter, raw_value|
@@ -261,7 +240,7 @@ module JSONAPI
       end
 
       def is_filter_association?(filter)
-        filter == _serialize_as || _associations.include?(filter)
+        filter == _type || _associations.include?(filter)
       end
 
       def verify_filter(filter, raw, context = nil)
@@ -291,6 +270,10 @@ module JSONAPI
       end
 
       # quasi private class methods
+      def _attribute_options(attr)
+        default_attribute_options.merge(@_attributes[attr])
+      end
+
       def _updateable_associations
         associations = []
 
@@ -303,11 +286,12 @@ module JSONAPI
       end
 
       def _has_association?(type)
-        @_associations.has_key?(type)
+        type = type.to_s
+        @_associations.has_key?(type.singularize.to_sym) || @_associations.has_key?(type.pluralize.to_sym)
       end
 
       def _association(type)
-        type = type.to_sym unless type.is_a?(Symbol)
+        type = type.to_sym
         @_associations[type]
       end
 
@@ -315,16 +299,12 @@ module JSONAPI
         @_model_name ||= self.name.demodulize.sub(/Resource$/, '')
       end
 
-      def _serialize_as
-        @_serialize_as ||= self._type
-      end
-
       def _key
         @_key ||= :id
       end
 
       def _as_parent_key
-        @_as_parent_key ||= "#{_serialize_as.to_s.singularize}_#{_key}"
+        @_as_parent_key ||= "#{_type.to_s.singularize}_#{_key}"
       end
 
       def _allowed_filters
@@ -351,11 +331,7 @@ module JSONAPI
       end
 
       def _allowed_filter?(filter)
-        _allowed_filters.include?(filter.to_sym)
-      end
-
-      def _validate_field(field)
-        _attributes.include?(field) || _associations.key?(field)
+        _allowed_filters.include?(filter)
       end
 
       private
@@ -374,7 +350,7 @@ module JSONAPI
             end unless method_defined?(key)
 
             define_method "_#{attr}_object" do
-              type_name = self.class._associations[attr].serialize_type_name
+              type_name = self.class._associations[attr].type
               resource_class = self.class.resource_for(type_name)
               if resource_class
                 associated_object = @object.send attr
@@ -389,7 +365,7 @@ module JSONAPI
             end unless method_defined?(key)
 
             define_method "_#{attr}_objects" do
-              type_name = self.class._associations[attr].serialize_type_name
+              type_name = self.class._associations[attr].type
               resource_class = self.class.resource_for(type_name)
               resources = []
               if resource_class
@@ -403,15 +379,6 @@ module JSONAPI
           end
         end
       end
-
-      def verify_permitted_params(params, allowed_param_set)
-        params_not_allowed = []
-        params.keys.each do |key|
-          param = key.to_sym
-          params_not_allowed.push(param) unless allowed_param_set.include?(param)
-        end
-        raise JSONAPI::Exceptions::ParametersNotAllowed.new(params_not_allowed) if params_not_allowed.length > 0
-      end
     end
   end
-end
+end

data/lib/jsonapi/resource_controller.rb

@@ -15,7 +15,10 @@ module JSONAPI
 
     before_filter {
       begin
-        @request = JSONAPI::Request.new(context, params)
+        @request = JSONAPI::Request.new(params, {
+          context: context,
+          key_formatter: key_formatter
+        })
         render_errors(@request.errors) unless @request.errors.empty?
       rescue => e
         handle_exceptions(e)
@@ -23,11 +26,13 @@ module JSONAPI
     }
 
     def index
-      render json: JSONAPI::ResourceSerializer.new.serialize(
+      render json: JSONAPI::ResourceSerializer.new.serialize_to_hash(
           resource_klass.find(resource_klass.verify_filters(@request.filters, context), context),
-          @request.includes,
-          @request.fields,
-          context)
+          include: @request.include,
+          fields: @request.fields,
+          context: context,
+          attribute_formatters: attribute_formatters,
+          key_formatter: key_formatter)
     rescue => e
       handle_exceptions(e)
     end
@@ -35,16 +40,22 @@ module JSONAPI
     def show
       keys = parse_key_array(params[resource_klass._key])
 
-      resources = []
-      keys.each do |key|
-        resources.push(resource_klass.find_by_key(key, context))
+      if keys.length > 1
+        resources = []
+        keys.each do |key|
+          resources.push(resource_klass.find_by_key(key, context))
+        end
+      else
+        resources = resource_klass.find_by_key(keys[0], context)
       end
 
-      render json: JSONAPI::ResourceSerializer.new.serialize(
+      render json: JSONAPI::ResourceSerializer.new.serialize_to_hash(
           resources,
-          @request.includes,
-          @request.fields,
-          context)
+          include: @request.include,
+          fields: @request.fields,
+          context: context,
+          attribute_formatters: attribute_formatters,
+          key_formatter: key_formatter)
     rescue => e
       handle_exceptions(e)
     end
@@ -70,6 +81,10 @@ module JSONAPI
       process_request_operations
     end
 
+    def update_association
+      process_request_operations
+    end
+
     def update
       process_request_operations
     end
@@ -115,6 +130,20 @@ module JSONAPI
       {}
     end
 
+    # Control by setting in an initializer:
+    #     JSONAPI.configuration.json_key_format = :camelized_key
+    #
+    # 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
+
+    # override to setup custom attribute_formatters
+    def attribute_formatters
+      {}
+    end
+
     def render_errors(errors, status = :bad_request)
       render(json: {errors: errors}, status: errors.count == 1 ? errors[0].status : status)
     end
@@ -138,18 +167,17 @@ module JSONAPI
       if errors.count > 0
         render :status => errors.count == 1 ? errors[0].status : :bad_request, json: {errors: errors}
       else
-        # if patch
-          render :status => results[0].code, json: JSONAPI::ResourceSerializer.new.serialize(resources,
-                                                                                               @request.includes,
-                                                                                               @request.fields,
-                                                                                               context)
-        # else
-        #   result_hash = {}
-        #   resources.each do |resource|
-        #     result_hash.merge!(JSONAPI::ResourceSerializer.new.serialize(resource, @request.includes, @request.fields, context))
-        #   end
-        #   render :status => results.count == 1 ? results[0].code : :ok, json: result_hash
-        # end
+        if results.length > 0 && resources.length > 0
+          render :status => results[0].code,
+                 json: JSONAPI::ResourceSerializer.new.serialize_to_hash(resources.length > 1 ? resources : resources[0],
+                                                                         include: @request.include,
+                                                                         fields: @request.fields,
+                                                                         context: context,
+                                                                         attribute_formatters: attribute_formatters,
+                                                                         key_formatter: key_formatter)
+        else
+          render :status => results[0].code, json: nil
+        end
       end
     rescue => e
       handle_exceptions(e)
@@ -166,4 +194,4 @@ module JSONAPI
       end
     end
   end
-end
+end

data/lib/jsonapi/resource_for.rb

@@ -7,12 +7,10 @@ module JSONAPI
     module ClassMethods
       if RUBY_VERSION >= '2.0'
         def resource_for(type)
-          begin
-            resource_name = JSONAPI::Resource._resource_name_from_type(type)
-            Object.const_get resource_name if resource_name
-          rescue NameError
-            nil
-          end
+          resource_name = JSONAPI::Resource._resource_name_from_type(type)
+          Object.const_get resource_name if resource_name
+        rescue NameError
+          nil
         end
       else
         def resource_for(type)

data/lib/jsonapi/resource_serializer.rb

@@ -1,7 +1,7 @@
 module JSONAPI
   class ResourceSerializer
 
-    # Serializes a single resource, or an array of resources
+    # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
     # include:
     #     Purpose: determines which objects will be side loaded with the source objects in a linked section
     #     Example: ['comments','author','comments.tags','author.posts']
@@ -9,45 +9,56 @@ module JSONAPI
     #     Purpose: determines which fields are serialized for a resource type. This encompasses both attributes and
     #              association ids in the links section for a resource. Fields are global for a resource type.
     #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
-    def serialize(source, include = [], fields = {}, context = nil)
-      @fields = fields
-      @context = context
+    def serialize_to_hash(source, options = {})
+      is_resource_collection = source.respond_to?(:to_ary)
+      return {} if source.nil? || (is_resource_collection && source.size == 0)
+
+      @fields =  options.fetch(:fields, {})
+      include = options.fetch(:include, [])
+      @context = options.fetch(:context, nil)
+      @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
+
       @linked_objects = {}
 
       requested_associations = parse_includes(include)
 
-      if source.respond_to?(:to_ary)
-        return {} if source.size == 0
-        @primary_class_name = source[0].class._serialize_as
+      if is_resource_collection
+        @primary_class_name = source[0].class._type
       else
-        @primary_class_name = source.class._serialize_as
+        @primary_class_name = source.class._type
       end
 
       process_primary(source, requested_associations)
 
       primary_class_name = @primary_class_name.to_sym
-      primary_hash = {primary_class_name => []}
 
       linked_hash = {}
+      primary_objects = []
       @linked_objects.each do |class_name, objects|
         class_name = class_name.to_sym
 
-        linked = []
+        linked_objects = []
         objects.each_value do |object|
           if object[:primary]
-            primary_hash[primary_class_name].push(object[:object_hash])
+            primary_objects.push(object[:object_hash])
           else
-            linked.push(object[:object_hash])
+            linked_objects.push(object[:object_hash])
           end
         end
-        linked_hash[class_name] = linked unless linked.empty?
+        linked_hash[format_key(class_name)] = linked_objects unless linked_objects.empty?
       end
 
-      if linked_hash.size > 0
-        primary_hash.merge!({linked: linked_hash})
+      if is_resource_collection
+        primary_hash = {format_key(primary_class_name) => primary_objects}
+      else
+        primary_hash = {format_key(primary_class_name) => primary_objects[0]}
       end
 
-      return primary_hash
+      if linked_hash.size > 0
+        primary_hash.merge({linked: linked_hash})
+      else
+        primary_hash
+      end
     end
 
     private
@@ -57,7 +68,7 @@ module JSONAPI
     def parse_includes(includes)
       requested_associations = {}
       includes.each do |include|
-        include = include.to_s if include.is_a? Symbol
+        include = include.to_s.underscore
 
         pos = include.index('.')
         if pos
@@ -112,14 +123,17 @@ module JSONAPI
     end
 
     def attribute_hash(source)
-      requested = requested_fields(source.class._serialize_as)
-      fields = source.class._attributes.to_a
+      requested = requested_fields(source.class._type)
+      fields = source.class._attributes.keys.to_a
       unless requested.nil?
         fields = requested & fields
       end
 
       source.fetchable(fields, @context).each_with_object({}) do |name, hash|
-        hash[name] = source.send(name)
+        hash[format_key(name)] = format_value(source.send(name),
+                                              source.class._attribute_options(name)[:format],
+                                              source,
+                                              @context)
       end
     end
 
@@ -127,7 +141,7 @@ module JSONAPI
     # class's fetchable method
     def links_hash(source, requested_associations)
       associations = source.class._associations
-      requested = requested_fields(source.class._serialize_as)
+      requested = requested_fields(source.class._type)
       fields = associations.keys
       unless requested.nil?
         fields = requested & fields
@@ -141,7 +155,7 @@ module JSONAPI
           key = association.key
 
           if field_set.include?(name)
-            hash[name] = source.send(key)
+            hash[format_key(name)] = source.send(key)
           end
 
           ia = requested_associations.is_a?(Hash) ? requested_associations[name] : nil
@@ -149,7 +163,7 @@ module JSONAPI
           include_linked_object = ia && ia[:include]
           include_linked_children = ia && ia[:include_children]
 
-          type = association.serialize_type_name
+          type = association.type
 
           # If the object has been serialized once it will be in the related objects list,
           # but it's possible all children won't have been captured. So we must still go
@@ -157,13 +171,14 @@ module JSONAPI
           if include_linked_object || include_linked_children
             if association.is_a?(JSONAPI::Association::HasOne)
               object = source.send("_#{name}_object")
-
-              id = object.send(association.primary_key)
-              associations_only = already_serialized?(type, id)
-              if include_linked_object && !associations_only
-                add_linked_object(type, id, object_hash(object, ia[:include_related]))
-              elsif include_linked_children || associations_only
-                links_hash(object, ia[:include_related])
+              if object
+                id = object.send(association.primary_key)
+                associations_only = already_serialized?(type, id)
+                if include_linked_object && !associations_only
+                  add_linked_object(type, id, object_hash(object, ia[:include_related]))
+                elsif include_linked_children || associations_only
+                  links_hash(object, ia[:include_related])
+                end
               end
             elsif association.is_a?(JSONAPI::Association::HasMany)
               objects = source.send("_#{name}_objects")
@@ -183,16 +198,20 @@ module JSONAPI
     end
 
     def already_serialized?(type, id)
+      type = format_key(type)
       return @linked_objects.key?(type) && @linked_objects[type].key?(id)
     end
 
     # Sets that an object should be included in the primary document of the response.
     def set_primary(type, id)
+      type = format_key(type)
       @linked_objects[type][id][:primary] = true
     end
 
     # Collects the hashes for all objects processed by the serializer
     def add_linked_object(type, id, object_hash, primary = false)
+      type = format_key(type)
+
       unless @linked_objects.key?(type)
         @linked_objects[type] = {}
       end
@@ -205,5 +224,14 @@ module JSONAPI
         @linked_objects[type].store(id, {primary: primary, object_hash: object_hash})
       end
     end
+
+    def format_key(key)
+      @key_formatter.format(key)
+    end
+
+    def format_value(value, format, source, context)
+      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
+      value_formatter.format(value, source, context)
+    end
   end
-end
+end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/jsonapi/routing_ext.rb

@@ -47,7 +47,7 @@ module ActionDispatch
         end
 
         def links_methods(options)
-          default_methods = [:show, :create, :destroy]
+          default_methods = [:show, :create, :destroy, :update]
           if only = options[:only]
             Array(only).map(&:to_sym)
           elsif except = options[:except]
@@ -73,6 +73,10 @@ module ActionDispatch
             match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
           end
 
+          if methods.include?(:update)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'update_association', association: link_type.to_s, via: [:put]
+          end
+
           if methods.include?(:destroy)
             match "links/#{link_type}", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
           end
@@ -94,6 +98,10 @@ module ActionDispatch
             match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
           end
 
+          if methods.include?(:update) && res._association(link_type).acts_as_set
+            match "links/#{link_type}", controller: res._type.to_s, action: 'update_association', association: link_type.to_s, via: [:put]
+          end
+
           if methods.include?(:destroy)
             match "links/#{link_type}/:keys", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
           end

data/lib/jsonapi-resources.rb

@@ -1,2 +1,4 @@
 require 'jsonapi/resource'
 require 'jsonapi/resources/version'
+require 'jsonapi/configuration'
+require 'jsonapi/formatter'