jsonapi-resources 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54ace53b12009a3a05a2ecb95ad41de0521e11e1
-  data.tar.gz: 276a1910eebc42ffea72005edc6b837fb15a29ac
+  metadata.gz: f70ae71e6004b279c357d07b852d3be4eebc03d6
+  data.tar.gz: bc3fc2fae00f4e4d3a5c6d602bc42659181d7a02
 SHA512:
-  metadata.gz: 2203b61b306a9c646482a156cdc3a073352ce91c683c837821342cf5c84f4910ce7e86e02938070176457362c63b275b27d70c5f08425e4244d462df21d49263
-  data.tar.gz: 27370f259cfc82e4fb3da10b5ea78e04462b563ac870e7ad0c46bdd7bca3fc5240989179cf02b7ef7464ca3787dce1edacb76512b6ff8bf59a3bbe343909ad7d
+  metadata.gz: bfb971dee293f36ba1e4a78f6b5db0e9d7a4dbe4be1b38cd66fcb183aefb0935497472e3e1ea72a3ca41be551b96de887dd00c3a323814c8b16b1ad9b03a2e64
+  data.tar.gz: c2c3b13c7c58ee1a7b7a4e1c029477965a927413910944fb9f8837f5faec61af765198a1da618ee493431e12a7eea402b53e8368998f68344eb5eb36b7f1c7d3

data/README.md

@@ -63,7 +63,7 @@ end
 
 This resource has 5 attributes: `:id`, `:name_first`, `:name_last`, `:email`, `:twitter`. By default these attributes must exist on the model that is handled by the resource.
 
-A resource object wraps a Ruby object, usually an ActiveModel record, which is available as the `@object` variable. This allows a resource's methods to access the underlying object.
+A resource object wraps a Ruby object, usually an ActiveModel record, which is available as the `@model` variable. This allows a resource's methods to access the underlying model.
 
 For example, a computed attribute for `full_name` could be defined as such:
 
@@ -75,7 +75,7 @@ class ContactResource < JSONAPI::Resource
   attribute :full_name
 
   def full_name
-    "#{@object.name_first}, #{@object.name_last}"
+    "#{@model.name_first}, #{@model.name_last}"
   end
 end
 ```
@@ -117,7 +117,7 @@ class ContactResource < JSONAPI::Resource
   attributes :id, :name_first, :name_last, :full_name
 
   def full_name
-    "#{@object.name_first}, #{@object.name_last}"
+    "#{@model.name_first}, #{@model.name_last}"
   end
 
   def self.updateable_fields(context)
@@ -458,13 +458,13 @@ JR by default uses some simple rules to format an attribute for serialization. S
 
 If you want to change the way an attribute is serialized you have a couple of ways. The simplest method is to create a getter method on the resource which overrides the attribute and apply the formatting there. For example:
 
-```
+```ruby
 class PersonResource < JSONAPI::Resource
   attributes :id, :name, :email
   attribute :last_login_time
 
   def last_login_time
-    @object.last_login_time.in_time_zone('Eastern Time (US & Canada)').to_s
+    @model.last_login_time.in_time_zone(@context[:current_user].time_zone).to_s
   end
 end
 ```
@@ -475,7 +475,7 @@ This is simple to implement for a one off situation, but not for example if you
 
 To overcome the above limitations JR uses Value Formatters. Value Formatters allow you to control the way values are handled for an attribute. The `format` can be set per attribute as it is declared in the resource. For example:
 
-```
+```ruby
 class PersonResource < JSONAPI::Resource
   attributes :id, :name, :email
   attribute :last_login_time, format: :date_with_timezone
@@ -484,15 +484,15 @@ end
 
 A Value formatter has a `format` and an `unformat` method. Here's the base ValueFormatter and DefaultValueFormatter for reference:
 
-```
+```ruby
 module JSONAPI
   class ValueFormatter < Formatter
     class << self
-      def format(raw_value, source, context)
+      def format(raw_value, context)
         super(raw_value)
       end
 
-      def unformat(value, resource_klass, context)
+      def unformat(value, context)
         super(value)
       end
       ...
@@ -502,7 +502,7 @@ end
 
 class DefaultValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
+    def format(raw_value, context)
       case raw_value
         when String, Integer
           return raw_value
@@ -516,15 +516,15 @@ end
 
 You can also create your own Value Formatter. Value Formatters must be named with the `format` name followed by `ValueFormatter`, i.e. `DateWithTimezoneValueFormatter` and derive from `JSONAPI::ValueFormatter`. It is recommended that you create a directory for your formatters, called `formatters`.
 
-The `format` method is called by the ResourceSerializer as is serializing a resource. The format method takes the `raw_value`, `source`, and `context` parameters. `raw_value` is the value as read from the model, `source` is the resource instance itself, and `context` is the context of the current user/request. From this you can base the formatted version of the attribute on other values on the resource or the current context.
+The `format` method is called by the ResourceSerializer as is serializing a resource. The format method takes the `raw_value`, and `context` parameters. `raw_value` is the value as read from the model, and `context` is the context of the current user/request. From this you can base the formatted version of the attribute current context.
 
-The `unformat` method is called when processing the request. Each incoming attribute (except `links`) are run through the `unformat` method. The `unformat` method takes the `value`, `resource_klass`, and `context` parameters. `value` is the value as it comes in on the request, `resource_klass` is the resource that is being updated or created, and `context` is the context of the current user/request. This allows you process the incoming value to alter its state before it is stored in the model. By default no processing is applied.
+The `unformat` method is called when processing the request. Each incoming attribute (except `links`) are run through the `unformat` method. The `unformat` method takes the `value`, and `context` parameters. `value` is the value as it comes in on the request, and `context` is the context of the current user/request. This allows you process the incoming value to alter its state before it is stored in the model. By default no processing is applied.
 
 ###### Use a Different Default Value Formatter
 
 Another way to handle formatting is to set a different default value formatter. This will affect all attributes that do notw have a `format` set. You can do this by overriding the `default_attribute_options` method for a resource (or a base resource for a system wide change).
 
-```
+```ruby
   def default_attribute_options
     {format: :my_default}
   end
@@ -532,15 +532,15 @@ Another way to handle formatting is to set a different default value formatter.
 
 and
 
-```
+```ruby
 class MyDefaultValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
+    def format(raw_value, context)
       case raw_value
         when String, Integer
           return raw_value
         when DateTime
-          return raw_value.in_time_zone('Eastern Time (US & Canada)').to_s
+          return raw_value.in_time_zone(context[:current_user].time_zone).to_s
         else
           return raw_value.to_s
       end
@@ -566,7 +566,7 @@ end
 
 This will cause the serializer to use the CamelizedKeyFormatter. Besides UnderscoredKeyFormatter and CamelizedKeyFormatter JR defines the DasherizedKeyFormatter. You can also create your own KeyFormatter, for example:
 
-```
+```ruby
 class UpperCamelizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
     def format(key)

data/lib/jsonapi/formatter.rb

@@ -37,11 +37,11 @@ module JSONAPI
 
   class ValueFormatter < Formatter
     class << self
-      def format(raw_value, source, context)
+      def format(raw_value, context)
         super(raw_value)
       end
 
-      def unformat(value, resource_klass, context)
+      def unformat(value, context)
         super(value)
       end
 
@@ -82,7 +82,7 @@ end
 
 class DefaultValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
+    def format(raw_value, context)
       case raw_value
         when String, Integer
           return raw_value

data/lib/jsonapi/operation.rb

@@ -20,9 +20,9 @@ module JSONAPI
     end
 
     def apply(context)
-      resource = @resource_klass.new
-      resource.replace_fields(@values, context)
-      resource.save(context)
+      resource = @resource_klass.create(context)
+      resource.replace_fields(@values)
+      resource.save
 
       return JSONAPI::OperationResult.new(:created, resource)
 
@@ -40,7 +40,7 @@ module JSONAPI
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
-      resource.remove(context)
+      resource.remove
 
       return JSONAPI::OperationResult.new(:no_content)
 
@@ -63,8 +63,8 @@ module JSONAPI
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
-      resource.replace_fields(values, context)
-      resource.save(context)
+      resource.replace_fields(values)
+      resource.save
 
       return JSONAPI::OperationResult.new(:ok, resource)
     end
@@ -82,8 +82,8 @@ module JSONAPI
 
     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)
+      resource.create_has_one_link(@association_type, @key_value)
+      resource.save
 
       return JSONAPI::OperationResult.new(:no_content)
     end
@@ -101,8 +101,8 @@ module JSONAPI
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
-      resource.replace_has_one_link(@association_type, @key_value, context)
-      resource.save(context)
+      resource.replace_has_one_link(@association_type, @key_value)
+      resource.save
 
       return JSONAPI::OperationResult.new(:no_content)
     end
@@ -121,7 +121,7 @@ module JSONAPI
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
       @key_values.each do |value|
-        resource.create_has_many_link(@association_type, value, context)
+        resource.create_has_many_link(@association_type, value)
       end
 
       return JSONAPI::OperationResult.new(:no_content)
@@ -140,8 +140,8 @@ module JSONAPI
 
     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)
+      resource.replace_has_many_links(@association_type, @key_values)
+      resource.save
 
       return JSONAPI::OperationResult.new(:no_content)
     end
@@ -159,7 +159,7 @@ module JSONAPI
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
-      resource.remove_has_many_link(@association_type, @associated_key, context)
+      resource.remove_has_many_link(@association_type, @associated_key)
 
       return JSONAPI::OperationResult.new(:no_content)
 
@@ -179,8 +179,8 @@ module JSONAPI
 
     def apply(context)
       resource = @resource_klass.find_by_key(@resource_id, context)
-      resource.remove_has_one_link(@association_type, context)
-      resource.save(context)
+      resource.remove_has_one_link(@association_type)
+      resource.save
 
       return JSONAPI::OperationResult.new(:no_content)
     end

data/lib/jsonapi/request.rb

@@ -182,15 +182,15 @@ module JSONAPI
         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)
+          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))
+              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))
+            keys.push(@resource_klass.resource_for(association.type).verify_key(value, @context))
           end
           checked_has_many_associations[param] = keys
         else
@@ -207,7 +207,7 @@ module JSONAPI
 
     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)
+      value_formatter.unformat(value, @context)
     end
 
     def verify_permitted_params(params, allowed_fields)
@@ -368,7 +368,7 @@ module JSONAPI
     def parse_key_array(raw)
       keys = []
       raw.split(/,/).collect do |key|
-        keys.push @resource_klass.verify_key(key, context)
+        keys.push @resource_klass.verify_key(key, @context)
       end
       return keys
     end

data/lib/jsonapi/resource.rb

@@ -8,89 +8,87 @@ module JSONAPI
 
     @@resource_types = {}
 
-    attr_reader :object
+    attr :context
+    attr_reader :model
 
-    def initialize(object = create_new_object)
-      @object = object
+    def initialize(model, context = nil)
+      @model = model
+      @context = context
     end
 
-    def create_new_object
-      self.class._model_class.new
+    def remove
+      @model.destroy
     end
 
-    def remove(context)
-      @object.destroy
-    end
-
-    def create_has_many_link(association_type, association_key_value, context)
+    def create_has_many_link(association_type, association_key_value)
       association = self.class._associations[association_type]
-      related_resource = self.class.resource_for(association.type).find_by_key(association_key_value, context)
+      related_resource = self.class.resource_for(association.type).find_by_key(association_key_value, @context)
 
       # 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
+      relation = @model.send(association.type).where(association.primary_key => association_key_value).first
       if relation.nil?
-        @object.send(association.type) << related_resource.object
+        @model.send(association.type) << related_resource.model
       else
         raise JSONAPI::Exceptions::HasManyRelationExists.new(association_key_value)
       end
     end
 
-    def replace_has_many_links(association_type, association_key_values, context)
+    def replace_has_many_links(association_type, association_key_values)
       association = self.class._associations[association_type]
 
-      @object.send("#{association.key}=", association_key_values)
+      @model.send("#{association.key}=", association_key_values)
     end
 
-    def create_has_one_link(association_type, association_key_value, context)
+    def create_has_one_link(association_type, association_key_value)
       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}")
+      relation = @model.send("#{association.key}")
       if relation.nil?
-        @object.send("#{association.key}=", association_key_value)
+        @model.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)
+    def replace_has_one_link(association_type, association_key_value)
       association = self.class._associations[association_type]
 
-      @object.send("#{association.key}=", association_key_value)
+      @model.send("#{association.key}=", association_key_value)
     end
 
-    def remove_has_many_link(association_type, key, context)
+    def remove_has_many_link(association_type, key)
       association = self.class._associations[association_type]
 
-      @object.send(association.type).delete(key)
+      @model.send(association.type).delete(key)
     end
 
-    def remove_has_one_link(association_type, context)
+    def remove_has_one_link(association_type)
       association = self.class._associations[association_type]
 
-      @object.send("#{association.key}=", nil)
+      @model.send("#{association.key}=", nil)
     end
 
-    def replace_fields(field_data, context)
+    def replace_fields(field_data)
       field_data[:attributes].each do |attribute, value|
         send "#{attribute}=", value
       end
 
       field_data[:has_one].each do |association_type, value|
         if value.nil?
-          remove_has_one_link(association_type, context)
+          remove_has_one_link(association_type)
         else
-          replace_has_one_link(association_type, value, context)
+          replace_has_one_link(association_type, value)
         end
       end if field_data[:has_one]
 
       field_data[:has_many].each do |association_type, values|
-        replace_has_many_links(association_type, values, context)
+        replace_has_many_links(association_type, values)
       end if field_data[:has_many]
     end
 
-    def save(context)
-      @object.save!
+    def save
+      @model.save!
     rescue ActiveRecord::RecordInvalid => e
       errors = []
       e.record.errors.messages.each do |element|
@@ -107,7 +105,7 @@ module JSONAPI
     end
 
     # Override this on a resource instance to override the fetchable keys
-    def fetchable_fields(context)
+    def fetchable_fields
       self.class.fields
     end
 
@@ -127,6 +125,14 @@ module JSONAPI
 
       attr_accessor :_attributes, :_associations, :_allowed_filters , :_type
 
+      def create(context)
+        self.new(self.create_model, context)
+      end
+
+      def create_model
+        _model_class.new
+      end
+
       def routing_options(options)
         @_routing_resource_options = options
       end
@@ -145,11 +151,11 @@ module JSONAPI
       def attribute(attr, options = {})
         @_attributes[attr] = options
         define_method attr do
-          @object.send(attr)
+          @model.send(attr)
         end unless method_defined?(attr)
 
         define_method "#{attr}=" do |value|
-          @object.send "#{attr}=", value
+          @model.send "#{attr}=", value
         end unless method_defined?("#{attr}=")
       end
 
@@ -182,12 +188,12 @@ module JSONAPI
       end
 
       # Override in your resource to filter the updateable keys
-      def updateable_fields(context)
+      def updateable_fields(context = nil)
         _updateable_associations | _attributes.keys
       end
 
       # Override in your resource to filter the createable keys
-      def createable_fields(context)
+      def createable_fields(context = nil)
         _updateable_associations | _attributes.keys
       end
 
@@ -214,19 +220,19 @@ module JSONAPI
         end
 
         resources = []
-        _model_class.where(where_filters).includes(includes).each do |object|
-          resources.push self.new(object)
+        _model_class.where(where_filters).includes(includes).each do |model|
+          resources.push self.new(model, context)
         end
 
         return resources
       end
 
       def find_by_key(key, context = nil)
-        obj = _model_class.where({_key => key}).first
-        if obj.nil?
+        model = _model_class.where({_key => key}).first
+        if model.nil?
           raise JSONAPI::Exceptions::RecordNotFound.new(key)
         end
-        self.new(obj)
+        self.new(model, context)
       end
 
       def verify_filters(filters, context = nil)
@@ -345,36 +351,36 @@ module JSONAPI
             key = @_associations[attr].key
 
             define_method key do
-              @object.method(key).call
+              @model.method(key).call
             end unless method_defined?(key)
 
-            define_method "_#{attr}_object" do
+            define_method "_#{attr}_resource" do
               type_name = self.class._associations[attr].type
               resource_class = self.class.resource_for(type_name)
               if resource_class
-                associated_object = @object.send attr
-                return resource_class.new(associated_object)
+                associated_model = @model.send attr
+                return resource_class.new(associated_model, @context)
               end
-            end
+            end unless method_defined?("_#{attr}_resource")
           elsif @_associations[attr].is_a?(JSONAPI::Association::HasMany)
             key = @_associations[attr].key
 
             define_method key do
-              @object.method(key).call
+              @model.method(key).call
             end unless method_defined?(key)
 
-            define_method "_#{attr}_objects" do
+            define_method "_#{attr}_resources" do
               type_name = self.class._associations[attr].type
               resource_class = self.class.resource_for(type_name)
               resources = []
               if resource_class
-                associated_objects = @object.send attr
-                associated_objects.each do |associated_object|
-                  resources.push resource_class.new(associated_object)
+                associated_models = @model.send attr
+                associated_models.each do |associated_model|
+                  resources.push resource_class.new(associated_model, @context)
                 end
               end
               return resources
-            end
+            end unless method_defined?("_#{attr}_resources")
           end
         end
       end

data/lib/jsonapi/resource_controller.rb

@@ -13,24 +13,13 @@ module JSONAPI
   class ResourceController < ActionController::Base
     include ResourceFor
 
-    before_filter {
-      begin
-        @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
-    }
+    before_filter :setup_request
 
     def index
       render json: JSONAPI::ResourceSerializer.new.serialize_to_hash(
           resource_klass.find(resource_klass.verify_filters(@request.filters, context), context),
           include: @request.include,
           fields: @request.fields,
-          context: context,
           attribute_formatters: attribute_formatters,
           key_formatter: key_formatter)
     rescue => e
@@ -53,7 +42,6 @@ module JSONAPI
           resources,
           include: @request.include,
           fields: @request.fields,
-          context: context,
           attribute_formatters: attribute_formatters,
           key_formatter: key_formatter)
     rescue => e
@@ -117,6 +105,16 @@ module JSONAPI
       @resource_klass_name ||= "#{self.class.name.demodulize.sub(/Controller$/, '').singularize}Resource"
     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 parse_key_array(raw)
       keys = []
       raw.split(/,/).collect do |key|
@@ -172,7 +170,6 @@ module JSONAPI
                  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

data/lib/jsonapi/resource_serializer.rb

@@ -15,7 +15,7 @@ module JSONAPI
 
       @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 = {}
@@ -110,7 +110,7 @@ module JSONAPI
       end
     end
 
-    # Returns a serialized hash for the source object, with
+    # Returns a serialized hash for the source model, with
     def object_hash(source, requested_associations)
       obj_hash = attribute_hash(source)
       links = links_hash(source, requested_associations)
@@ -124,7 +124,7 @@ module JSONAPI
 
     def attribute_hash(source)
       requested = requested_fields(source.class._type)
-      fields = source.fetchable_fields(@context) & source.class._attributes.keys.to_a
+      fields = source.fetchable_fields & source.class._attributes.keys.to_a
       unless requested.nil?
         fields = requested & fields
       end
@@ -132,8 +132,7 @@ module JSONAPI
       fields.each_with_object({}) do |name, hash|
         hash[format_key(name)] = format_value(source.send(name),
                                               source.class._attribute_options(name)[:format],
-                                              source,
-                                              @context)
+                                              source)
       end
     end
 
@@ -149,7 +148,7 @@ module JSONAPI
 
       field_set = Set.new(fields)
 
-      included_associations = source.fetchable_fields(@context) & associations.keys
+      included_associations = source.fetchable_fields & associations.keys
       associations.each_with_object({}) do |(name, association), hash|
         if included_associations.include? name
           key = association.key
@@ -170,25 +169,25 @@ module JSONAPI
           # through the associations.
           if include_linked_object || include_linked_children
             if association.is_a?(JSONAPI::Association::HasOne)
-              object = source.send("_#{name}_object")
-              if object
-                id = object.send(association.primary_key)
+              resource = source.send("_#{name}_resource")
+              if resource
+                id = resource.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]))
+                  add_linked_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
-                  links_hash(object, ia[:include_related])
+                  links_hash(resource, ia[:include_related])
                 end
               end
             elsif association.is_a?(JSONAPI::Association::HasMany)
-              objects = source.send("_#{name}_objects")
-              objects.each do |object|
-                id = object.send(association.primary_key)
+              resources = source.send("_#{name}_resources")
+              resources.each do |resource|
+                id = resource.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]))
+                  add_linked_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
-                  links_hash(object, ia[:include_related])
+                  links_hash(resource, ia[:include_related])
                 end
               end
             end
@@ -229,9 +228,9 @@ module JSONAPI
       @key_formatter.format(key)
     end
 
-    def format_value(value, format, source, context)
+    def format_value(value, format, source)
       value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
-      value_formatter.format(value, source, context)
+      value_formatter.format(value, source)
     end
   end
 end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = "0.0.6"
+    VERSION = "0.0.7"
   end
 end

data/test/fixtures/active_record.rb

@@ -288,7 +288,7 @@ class PersonResource < JSONAPI::Resource
 
   filter :name
 
-  def self.verify_custom_filter(filter, values, context = nil)
+  def self.verify_custom_filter(filter, values, context)
     case filter
       when :name
         values.each do |value|
@@ -308,22 +308,22 @@ class AuthorResource < JSONAPI::Resource
 
   filter :name
 
-  def self.find(filters, context = nil)
+  def self.find(filters, context)
     resources = []
 
     filters.each do |attr, filter|
-      _model_class.where("\"#{attr}\" LIKE \"%#{filter[0]}%\"").each do |object|
-        resources.push self.new(object)
+      _model_class.where("\"#{attr}\" LIKE \"%#{filter[0]}%\"").each do |model|
+        resources.push self.new(model, context)
       end
     end
     return resources
   end
 
-  def fetchable_fields(context)
-    if (@object.id % 2) == 1
-      super(context) - [:email]
+  def fetchable_fields
+    if (@model.id % 2) == 1
+      super - [:email]
     else
-      super(context)
+      super
     end
   end
 end
@@ -358,7 +358,7 @@ class PostResource < JSONAPI::Resource
   has_many :tags, acts_as_set: true
   has_many :comments, acts_as_set: false
   def subject
-    @object.title
+    @model.title
   end
 
   filters :title, :author, :tags, :comments
@@ -392,7 +392,7 @@ class PostResource < JSONAPI::Resource
 
   def self.verify_key(key, context = nil)
     raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key) unless is_num?(key)
-    raise JSONAPI::Exceptions::RecordNotFound.new(key) unless find_by_key(key)
+    raise JSONAPI::Exceptions::RecordNotFound.new(key) unless find_by_key(key, context)
     return key
   end
 end
@@ -419,13 +419,13 @@ class BreedResource < JSONAPI::Resource
   def self.find(attrs, context = nil)
     breeds = []
     $breed_data.breeds.values.each do |breed|
-      breeds.push(BreedResource.new(breed))
+      breeds.push(BreedResource.new(breed, context))
     end
     breeds
   end
 
   def self.find_by_key(id, context = nil)
-    BreedResource.new($breed_data.breeds[id.to_i])
+    BreedResource.new($breed_data.breeds[id.to_i], context)
   end
 end
 

data/test/test_helper.rb

@@ -113,7 +113,7 @@ end
 
 class DateWithTimezoneValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
+    def format(raw_value, context)
       raw_value.in_time_zone('Eastern Time (US & Canada)').to_s
     end
   end
@@ -121,7 +121,7 @@ end
 
 class DateValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
+    def format(raw_value, context)
       raw_value.strftime('%m/%d/%Y')
     end
   end
@@ -129,11 +129,11 @@ end
 
 class TitleValueFormatter < JSONAPI::ValueFormatter
   class << self
-    def format(raw_value, source, context)
-      super(raw_value, source, context).titlecase
+    def format(raw_value, source)
+      super(raw_value, source).titlecase
     end
 
-    def unformat(value, resource_klass, context)
+    def unformat(value, context)
       value.to_s.downcase
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-26 00:00:00.000000000 Z
+date: 2014-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler