served 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac32676f4fe8e2811b3e62f5f83012e4fe2b7034
-  data.tar.gz: 51b940bbb819c672d1144b77273d78eff11c13b1
+  metadata.gz: a4ea90b5253d1415e94853bf1654c93ff97f6b84
+  data.tar.gz: 8aabb4afe45f8233b64f1796212e694ff319c744
 SHA512:
-  metadata.gz: 9aaf0a3112b8ef71ac02b7a37129409f3b47a19e671a886f416f62f549b9c58c4e67c40fc82ceb74459cc6ca25518c610f969a8457b15640d9067e75db687c4f
-  data.tar.gz: 4bc38e706ef1eab00eecd7b88a9c33c83b973cc085e9e46bf1a189c8e5115ece33e869e17ccc04e75fd1b60b7fa9a359230279e7b39bbee8e01c09c592a967f2
+  metadata.gz: cf4c6bd4b29c2436f049948a41eb58ea1a7b36470b761543826694d2e049e7a7db30755ae74b91d2b7e3f00d5134c72f769396e8e9d99bae2601224d99d27be4
+  data.tar.gz: 5ffe22b04cca966d5f28f7d31159ccebb7ddc372d464f102c19e0bbb67f4c43915be1f857adf0b66cc1655b50973eba3f3ef3abb0bf32a220eb40911424f691c

data/.gitignore

@@ -8,4 +8,6 @@
 /spec/reports/
 /tmp/
 *.iml
-.idea/**
+.idea/**.rvmrc
+.rvmrc
+.idea/

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.0
+* Added Serializers feature, ability to define different methods of serializing resource response
+* New error handling, will report different errors based on response from resource
+* added `handler` response configuration, allows different handlers to be set up for specific
+  response codes.
+* added `Json` handler as default
+* added `JsonApi` handler
+
 ## 0.2.2
 * Resource::Base#destroy added, (backend functionality existed, but was never added to #resource)
 

data/README.md

@@ -24,6 +24,7 @@ Served.configure do |config|
    config.timeout = 100
    
    config.backend = :patron
+   config.serializer = Served::Serializers::Json
 end
 ```
 
@@ -96,6 +97,35 @@ class SomeService::SomeResource < Served::Resource::Base
 end
 ```
 
+## JsonAPI 
+
+Served does support JSON API responses and comes with a dedicated serializer. Nested resources are supported as well. 
+By default `Served` is raising exceptions on error.
+
+```ruby
+class JsonApiResource < Served::Resource::Base
+  serializer Served::Serializers::JsonApi
+
+  def self.raise_on_exceptions
+    false
+  end
+end
+
+class PeopleResource < JsonApiResource
+  attribute :name
+  resource_name 'friends'
+end
+
+class ServiceResource < JsonApiResource
+  attribute :id
+  attribute :first_name, presence: true
+  attribute :friends, serialize: PeopleResource, default: []
+
+  resource_name 'service_resource'
+end
+```
+
+
 ## Validations
 `Served::Resource::Base` includes `AciveModel::Validations` and supports all validation methods with the exception of 
 `Uniquness`. As a shotcut validations can be passed to the `#attribute` method much in the same way as it can be passed 
@@ -138,3 +168,16 @@ Served follows resourceful standards. When a resource is initially saved a **POS
 to the service. When the resource already exists, a **PUT** request will be sent. Served determines if
 a resource is new or not based on the presence of an id.
 
+### Service Errors
+
+If the service returns an error, by default an error is thrown. If you want it to behave more like AR where you get 
+validation errors and a `save` returns `true` or `false`, you can configure that.
+ 
+
+```ruby
+class JsonApiResource < Served::Resource::Base
+  def self.raise_on_exceptions
+    false
+  end
+end
+``` 

data/lib/served/attribute/base.rb

@@ -5,9 +5,6 @@ module Served
       include Resource::Serializable
       include Resource::Validatable
 
-      def initialize(*args)
-        # placeholder
-      end
     end
   end
 end

data/lib/served/config.rb

@@ -1,12 +1,15 @@
+require_relative 'serializers/json'
 module Served
   include ActiveSupport::Configurable
   config_accessor :timeout
   config_accessor :backend
+  config_accessor :serializer
 
   configure do |config|
-    config.timeout = 30
-    config.backend = :http
-    config.hosts   = {}
+    config.timeout    = 30
+    config.backend    = :http
+    config.hosts      = {}
+    config.serializer = Served::Serializers::Json
   end
 
 end

data/lib/served/error.rb

@@ -0,0 +1,13 @@
+module Served
+
+  # TODO: remove in 1.0, this preserves backwards compatibility with 0.2
+  module Resource
+    class Base
+      class ServiceError < StandardError
+      end
+    end
+  end
+
+  class Error < Served::Resource::Base::ServiceError
+  end
+end

data/lib/served/http_client.rb

@@ -1,4 +1,5 @@
 require 'addressable/template'
+require_relative 'error'
 module Served
   # Provides an interface between the HTTP client and the Resource.
   class HTTPClient
@@ -10,10 +11,10 @@ module Served
     delegate :get, :put, :delete, :post, to: :@backend
     delegate :headers, :timeout, :host,  to: :@resource
 
-    class ConnectionFailed < StandardError
+    class ConnectionFailed < Served::Error
 
         def initialize(resource)
-          super "Resource #{resource.name} could not be reached on #{resource.host}"
+          super "Resource '#{resource.name}' could not be reached on '#{resource.host}'"
         end
 
       end

data/lib/served/resource/attributable.rb

@@ -4,7 +4,7 @@ module Served
       extend ActiveSupport::Concern
 
       included do
-        prepend Prepend
+        include Serializable
         singleton_class.prepend ClassMethods::Prepend
       end
 
@@ -51,13 +51,9 @@ module Served
 
       end
 
-      module Prepend
-
-        def initialize(options={})
-          reload_with_attributes(options.symbolize_keys)
-          super options
-        end
-
+      def initialize(hash={})
+        reload_with_attributes(normalize_keys(hash) )
+        self
       end
 
       # @return [Array] the keys for all the defined attributes
@@ -67,11 +63,22 @@ module Served
 
       private
 
-      def reload_with_attributes(attributes)
-        attributes.each do |name, value|
-          set_attribute(name.to_sym, value)
+      # Reloads the instance with the new attributes
+      # If result is an Errors object it will create validation errors on the instance
+      # @return [Boolean]
+      def reload_with_attributes(result)
+        if result.is_a?(Served::Error)
+          serializer.parse_errors(result, self)
+          set_attribute_defaults
+          false
+        else
+          attributes = self.class.from_hash(result)
+          attributes.each do |name, value|
+            set_attribute(name.to_sym, value)
+          end
+          set_attribute_defaults
+          true
         end
-        set_attribute_defaults
       end
 
       def set_attribute_defaults
@@ -85,7 +92,17 @@ module Served
         instance_variable_set("@#{name}", value)
       end
 
-    end
+      def normalize_keys(params)
+        case params
+        when Hash
+          Hash[params.map { |k, v| [k.to_s.tr('-', '_'), normalize_keys(v)] }]
+        when Array
+          params.map { |v| normalize_keys(v) }
+        else
+          params
+        end
+      end
 
+    end
   end
 end

data/lib/served/resource/base.rb

@@ -1,7 +1,11 @@
 require_relative 'attributable'
 require_relative 'serializable'
 require_relative 'validatable'
+require_relative 'requestable'
 require_relative 'configurable'
+require_relative 'resource_invalid'
+
+require_relative 'http_errors'
 
 module Served
   module Resource
@@ -18,157 +22,13 @@ module Served
     # Served Resource, it will validate the nested resource as well as the top level.
     class Base
       include Configurable
+      include Requestable
       include Attributable
       include Validatable
       include Serializable
 
       attribute :id
 
-      # Default headers for every request
-      HEADERS = {'Content-type' => 'application/json', 'Accept' => 'application/json'}
-
-
-      # raised when the connection receives a response from a service that does not constitute a 200
-      class ServiceError < StandardError
-        attr_reader :response
-
-        def initialize(resource, response)
-          @response = response
-          begin
-            error = JSON.parse(response.body)
-          rescue JSON::ParserError
-            super "Service #{resource.class.name} experienced an error and sent back an invalid error response"
-            return
-          end
-          if error['error']
-            super "Service #{resource.class.name} responded with an error: #{error['error']} -> #{error['exception']}"
-            set_backtrace(error['traces']['Full Trace'].collect {|e| e['trace']})
-          end
-        end
-      end
-
-      class_configurable :resource_name do
-        name.split('::').last.tableize
-      end
-
-      class_configurable :host do
-        Served.config[:hosts][parent.name.underscore.split('/')[-1]] || Served.config[:hosts][:default]
-      end
-
-      class_configurable :timeout do
-        Served.config.timeout
-      end
-
-      class_configurable :_headers do
-        HEADERS
-      end
-
-      class_configurable :template do
-        '{/resource*}{/id}.json{?query*}'
-      end
-
-      class << self
-
-        # Defines the default headers that should be used for the request.
-        #
-        # @param headers [Hash] the headers to send with each requesat
-        # @return headers [Hash] the default headers for the class
-        def headers(h={})
-          headers ||= _headers
-          _headers(headers.merge!(h)) unless h.empty?
-          _headers
-        end
-
-        # Looks up a resource on the service by id. For example `SomeResource.find(5)` would call `/some_resources/5`
-        #
-        # @param id [Integer] the id of the resource
-        # @return [Resource::Base] the resource object.
-        def find(id)
-          instance = new(id: id)
-          instance.reload
-        end
-
-        # @return [Served::HTTPClient] the HTTPClient using the configured backend
-        def client
-          @client ||= Served::HTTPClient.new(self)
-        end
-
-      end
-
-      def initialize(options={})
-        # placeholder
-      end
-
-      # Saves the record to the service. Will call POST if the record does not have an id, otherwise will call PUT
-      # to update the record
-      #
-      # @return [Boolean] returns true or false depending on save success
-      def save
-        if id
-          reload_with_attributes(put[resource_name.singularize])
-        else
-          reload_with_attributes(post[resource_name.singularize])
-        end
-        true
-      end
-
-      # Reloads the resource using attributes from the service
-      #
-      # @return [self] self
-      def reload
-        reload_with_attributes(get)
-        self
-      end
-
-      # Destroys the record on the service. Acts on status code
-      # If code is a 204 (no content) it will simply return true
-      # otherwise it will parse the response and reloads the instance
-      #
-      # @return [Boolean|self] Returns true or instance
-      def destroy(params = {})
-        result = delete(params)
-        return result if result.is_a?(TrueClass)
-
-        reload_with_attributes(result)
-        self
-      end
-
-      private
-
-      def get(params={})
-        handle_response(client.get(resource_name, id, params))
-      end
-
-      def put(params={})
-        body = to_json
-        handle_response(client.put(resource_name, id, body, params))
-      end
-
-      def post(params={})
-        body = to_json
-        handle_response(client.post(resource_name, body, params))
-      end
-
-      def delete(params={})
-        response = client.delete(resource_name, id, params)
-        return true if response.code == 204
-
-        handle_response(response)
-      end
-
-      def handle_response(response)
-        raise ServiceError.new(self, response) unless (200..299).include?(response.code)
-        JSON.parse(response.body)
-      end
-
-      def client
-        self.class.client
-      end
-
-      def presenter
-        {resource_name.singularize.to_sym => attributes}
-      end
-
     end
   end
 end

data/lib/served/resource/http_errors.rb

@@ -0,0 +1,142 @@
+module Served
+  module Resource
+    class HttpError < Served::Error
+      attr_reader :message
+      attr_reader :server_backtrace
+      attr_reader :errors
+      attr_reader :response
+
+      # Defined in individual error classes
+      def self.code
+        raise NotImplementedError
+      end
+
+      def initialize(resource, response)
+        if resource.serializer.respond_to? :exception
+          serialized = resource.serializer.exception(response.body).symbolize_keys!
+
+          @error            = serialized[:error]
+          @message          = serialized[:exception]
+          @server_backtrace = serialized[:backtrace]
+          @code             = serialized[:code] || serialized[:code] = self.class.code
+          @response         = OpenStruct.new(serialized) # TODO: remove in served 1.0, used for backwards compat
+
+          super("An error '#{code} #{message}' occurred while making this request")
+        end
+        super "An error occurred '#{self.class.code}'"
+      end
+
+      def status
+        self.class.status
+      end
+
+      def code
+        @code
+      end
+
+    end
+
+    # 301 MovedPermanently
+    class MovedPermanently < HttpError
+
+      def self.code
+        301
+      end
+
+    end
+
+    # 400 BadRequest
+    class BadRequest < HttpError
+
+      def self.code
+        400
+      end
+
+    end
+
+    # 401 Unauthorized
+    class Unauthorized < HttpError
+
+      def self.code
+        401
+      end
+
+    end
+
+    # 403 Forbidden
+    class Forbidden < HttpError
+
+      def self.code
+        403
+      end
+
+    end
+
+    # 404 NotFound
+    class NotFound < HttpError
+
+      def self.code
+        404
+      end
+
+    end
+
+    # 405 MethodNotAllowed
+    class MethodNotAllowed < HttpError
+
+      def self.code
+        405
+      end
+
+    end
+
+    # 406 NotAcceptable
+    class NotAcceptable < HttpError
+
+      def self.code
+        406
+      end
+
+    end
+
+    # 408 RequestTimeout
+    class RequestTimeout < HttpError
+
+      def self.code
+        408
+      end
+
+    end
+
+    # 422 UnprocessableEntity
+    class UnprocessableEntity < HttpError
+
+      def self.code
+        422
+      end
+
+    end
+
+    # 500 InternalServerError
+    class InternalServerError < HttpError
+
+      def self.code
+        500
+      end
+
+    end
+
+    # 503 BadGateway
+    class BadGateway < HttpError
+
+      def self.code
+        503
+      end
+
+    end
+
+  end
+end
+
+
+

data/lib/served/resource/invalid_attribute_serializer.rb

@@ -0,0 +1,11 @@
+module Served
+  module Resource
+    class InvalidAttributeSerializer < Served::Error
+
+      def initialize(s)
+        super "'#{s}' attribute serializer does not exist"
+      end
+
+    end
+  end
+end

data/lib/served/resource/requestable.rb

@@ -0,0 +1,196 @@
+module Served
+  module Resource
+    module Requestable
+      extend ActiveSupport::Concern
+
+      # raised when a handler is defined if the method doesn't exist or if a proc isn't supplied
+      class HandlerRequired < StandardError
+
+        def initialize
+          super 'a handler is required, it must be a proc or a valid method'
+        end
+
+      end
+
+      HEADERS = { 'Content-type' => 'application/json', 'Accept' => 'application/json' }
+
+      included do
+        include Configurable
+
+        class_configurable :resource_name do
+          name.split('::').last.tableize
+        end
+
+        class_configurable :host do
+          Served.config[:hosts][parent.name.underscore.split('/')[-1]] || Served.config[:hosts][:default]
+        end
+
+        class_configurable :timeout do
+          Served.config.timeout
+        end
+
+        class_configurable :_headers do
+          HEADERS
+        end
+
+        class_configurable :handlers, default: {}
+
+        class_configurable :template do
+          '{/resource*}{/id}.json{?query*}'
+        end
+
+        class_configurable :raise_on_exceptions do
+          true
+        end
+
+        handle((200..201), :load)
+        handle([204, 202]) { attributes }
+
+        # 400 level errors
+        handle(301) { Resource::MovedPermanently }
+        handle(400) { Resource::BadRequest }
+        handle(401) { Resource::Unauthorized }
+        handle(403) { Resource::Forbidden }
+        handle(404) { Resource::NotFound }
+        handle(405) { Resource::MethodNotAllowed }
+        handle(406) { Resource::NotAcceptable }
+        handle(408) { Resource::RequestTimeout }
+        handle(422) { Resource::UnprocessableEntity }
+
+        # 500 level errors
+        handle(500) { Resource::InternalServerError }
+        handle(503) { Resource::BadGateway }
+
+
+      end
+
+      module ClassMethods
+
+        def handle_response(response)
+          if raise_on_exceptions
+            handler = handlers[response.code]
+            if handler.is_a? Proc
+              result = handler.call(response)
+            else
+              result = send(handler, response)
+            end
+            if result.is_a?(HttpError)
+              raise result.new(self, response)
+              result = Served::Serializers::JsonApi::Errors.new(response)
+            end
+            result
+          else
+            serializer.load(self, response)
+          end
+        end
+
+        # Sets individual handlers for response codes, accepts a proc or a symbol representing a method
+        #
+        # @param code [Integer|Range] the response code(s) the handler is to be assigned to
+        # @param symbol_or_proc [Symbol|Proc] a symbol representing the method to call, or a proc to be called when
+        #   the specific response code has been called. The method or proc should return a hash of attributes, if an
+        #   error class is returned it will be raised
+        # @yieldreturn [Hash] a hash of attributes, if an error class is returned it will be raised
+        def handle(code_or_range, symbol_or_proc=nil, &block)
+          raise HandlerRequired unless symbol_or_proc || block_given?
+          if code_or_range.is_a?(Range) || code_or_range.is_a?(Array)
+            code_or_range.each { |c|
+              handlers[c] = symbol_or_proc || block
+            }
+          else
+            handlers[code_or_range] = symbol_or_proc || block
+          end
+        end
+
+        # Defines the default headers that should be used for the request.
+        #
+        # @param headers [Hash] the headers to send with each requesat
+        # @return headers [Hash] the default headers for the class
+        def headers(h={})
+          headers ||= _headers
+          _headers(headers.merge!(h)) unless h.empty?
+          _headers
+        end
+
+        # Looks up a resource on the service by id. For example `SomeResource.find(5)` would call `/some_resources/5`
+        #
+        # @param id [Integer] the id of the resource
+        # @return [Resource::Base] the resource object.
+        def find(id, params = {})
+          instance = new(id: id)
+          instance.reload(params)
+        end
+
+        def all(params = {})
+          get(nil, params).map { |resource| new(resource) }
+        end
+
+        # @return [Served::HTTPClient] the HTTPClient using the configured backend
+        def client
+          @client ||= Served::HTTPClient.new(self)
+        end
+
+        def get(id, params = {})
+          handle_response(client.get(resource_name, id, params))
+        end
+      end
+
+      # Saves the record to the service. Will call POST if the record does not have an id, otherwise will call PUT
+      # to update the record
+      #
+      # @return [Boolean] returns true or false depending on save success
+      def save
+        id ? reload_with_attributes(put) : reload_with_attributes(post)
+      end
+
+      # Reloads the resource using attributes from the service
+      #
+      # @return [self] self
+      def reload(params = {})
+        reload_with_attributes(get(params))
+        self
+      end
+
+      # Destroys the record on the service. Acts on status code
+      # If code is a 204 (no content) it will simply return true
+      # otherwise it will parse the response and reloads the instance
+      #
+      # @return [Boolean|self] Returns true or instance
+      def destroy(params = {})
+        result = delete(params)
+        return result if result.is_a?(TrueClass)
+
+        reload_with_attributes(result)
+      end
+
+      private
+
+      def get(params = {})
+        self.class.get(id, params)
+      end
+
+      def put(params={})
+        handle_response(client.put(resource_name, id, dump, params))
+      end
+
+      def post(params={})
+        handle_response(client.post(resource_name, dump, params))
+      end
+
+      def delete(params={})
+        response = client.delete(resource_name, id, params)
+        return true if response.code == 204
+
+        handle_response(response)
+      end
+
+      def client
+        self.class.client
+      end
+
+      def handle_response(response)
+        self.class.handle_response(response)
+      end
+    end
+  end
+end

data/lib/served/resource/resource_invalid.rb

@@ -0,0 +1,9 @@
+module Served
+  module Resource
+    class ResourceInvalid < ::Served::Error
+      def initialize(resource)
+        super "[#{resource.errors.full_messages.join(', ')}]"
+      end
+    end
+  end
+end

data/lib/served/resource/response_invalid.rb

@@ -0,0 +1,13 @@
+module Served
+  module Resource
+    class ResponseInvalid < Served::Error
+
+      def initialize(resource, orignal_error=false)
+        return super "The resource '#{resource.name}' failed to serialize the response with message: " +
+                 "'#{orignal_error.message}'" if orignal_error
+        super "The resource '#{resource.name}' returned a response, but the result of serialization was `nil`"
+      end
+
+    end
+  end
+end

data/lib/served/resource/serializable.rb

@@ -1,3 +1,6 @@
+require_relative 'response_invalid'
+require_relative 'invalid_attribute_serializer'
+
 module Served
   module Resource
     module Serializable
@@ -9,76 +12,83 @@ module Served
         end
       end
 
-      # Specialized class serializers
-      SERIALIZERS = {
-          Fixnum => {call: :to_i},
-          String => {call: :to_s},
-          Symbol => {call: :to_sym, converter: -> (value) {
-            if value.is_a? Array
-              value = value.map { |a| a.to_sym }
-              return value
-            end
-          }},
-          Float => {call: :to_f},
-          Boolean => {converter: -> (value) {
-            return false unless value == "true"
-            true
-          }}
-      }
-
       included do
+        include Configurable
         include Attributable
-        prepend Prepend
-      end
 
-      class InvalidPresenter < StandardError
+        class_configurable :serializer, default: Served.config.serializer
+        class_configurable :use_root_node, default: Served.config.use_root_node
       end
 
-      module Prepend
+      module ClassMethods
 
-        def set_attribute(name, value)
-          return unless self.class.attributes[name]
-          if serializer = self.class.attributes[name][:serialize]
-            if serializer.is_a? Proc
-              value = serializer.call(value)
-            elsif s = SERIALIZERS[serializer]
-              called = false
-              if s[:call] && value.respond_to?(s[:call])
-                value = value.send(s[:call])
-                called = true
-              end
-              value = s[:converter].call(value) if s[:converter] && !called
-            else
-              value = serializer.new(value)
-            end
+        def load(string)
+          begin
+            result = serializer.load(self, string)
+          rescue => e
+            raise ResponseInvalid.new(self, e)
           end
-          super
+          raise ResponseInvalid.new(self) unless result
+          result
         end
 
-      end
-
-      module ClassMethods
+        def from_hash(hash)
+          hash.each do |name, value|
+            hash[name] = serialize_attribute(name, value)
+          end
+          hash.symbolize_keys
+        end
 
         private
 
-        def serializer_for_attribute(attr, serializer)
-          attributes[attr][:serializer] = serializer
+        def attribute_serializer_for(type)
+          # case statement wont work here because of how it does class matching
+          return ->(v) { return v }              unless type # nil
+          return ->(v) { return v.try(:to_i)   } if type == Integer || type == Fixnum
+          return ->(v) { return v.try(:to_s)   } if type == String
+          return ->(v) { return v.try(:to_sym) } if type == Symbol
+          return ->(v) { return v.try(:to_f)   } if type == Float
+          if type == Boolean
+            return lambda do |v|
+              return false unless v == "true"
+              true
+            end
+          end
+          return ->(v) { type.new(v) } if type.ancestors.include?(Served::Resource::Base) ||
+                                          type.ancestors.include?(Served::Attribute::Base)
+          raise InvalidAttributeSerializer, type
+        end
+
+        def serialize_attribute(attr, value)
+          return false unless attributes[attr.to_sym]
+          serializer = attribute_serializer_for(attributes[attr.to_sym][:serialize])
+          if value.is_a? Array
+            return value unless attributes[attr.to_sym][:serialize]
+            value.collect do |v|
+              if v.is_a? attributes[attr.to_sym][:serialize]
+                v
+              else
+                serializer.call(v)
+              end
+            end
+          else
+            serializer.call(value)
+          end
         end
 
       end
 
-      # renders the model as json
       def to_json(*args)
-        raise InvalidPresenter, 'Presenter must respond to #to_json' unless presenter.respond_to? :to_json
-        presenter.to_json
+        dump
       end
 
-      # override this to return a presenter to be used for serialization, otherwise all attributes will be
-      # serialized
-      def presenter
-        attributes
+      def dump
+        self.class.serializer.dump(self, attributes)
       end
 
+      def load(string)
+        self.class.serializer.load(string)
+      end
     end
   end
-end
+end

data/lib/served/resource/validatable.rb

@@ -12,16 +12,9 @@ module Served
           :inclusion,
       ]
 
-      class ResourceInvalid < StandardError
-
-        def initialize(resource)
-          super "[#{resource.errors.full_messages.join(', ')}]"
-        end
-      end
-
-      # Saves a resource and raises an error if the save fails.
+       # Saves a resource and raises an error if the save fails.
       def save!
-        raise ResourceInvalid.new(self) unless run_validations! && save(false)
+        raise ::Served::Resource::ResourceInvalid.new(self) unless run_validations! && save(false)
         true
       end
 

data/lib/served/serializers/json.rb

@@ -0,0 +1,32 @@
+require 'json'
+module Served
+  module Serializers
+
+    # The default serializer assumes that the default Rails API response is used for both data and errors.
+    module Json
+
+      def self.load(resource, data)
+        parsed = JSON.parse(data)
+        # assume we need to return the entire response if it isn't
+        # namespaced by keys. TODO: remove after 1.0, this is strictly for backwards compatibility
+        resource_name = resource.resource_name
+        if resource_name.is_a? Array
+          warn '[DEPRECATION] passing an array for resource name will no longer be supported in Served 1.0, ' +
+              'please ensure a single string is returned instead'
+          resource_name = resource_name.last  # backwards compatibility
+        end
+        parsed[resource_name.singularize] || parsed
+      end
+
+      def self.dump(resource, attributes)
+        a = Hash[attributes.collect { |k,v| v.blank? ? nil : [k,v] }.compact]
+        {resource.resource_name.singularize => a}.to_json
+      end
+
+      def self.exception(data)
+        JSON.parse(data)
+      end
+
+    end
+  end
+end

data/lib/served/serializers/json_api/error.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+module Served
+  module Serializers
+    module JsonApi
+      # Error object
+      class Error < ::Served::Error
+        delegate :[], to: :attrs
+
+        def initialize(attrs = {})
+          @attrs = (attrs || {}).with_indifferent_access
+        end
+
+        def id
+          attrs[:id]
+        end
+
+        def status
+          attrs[:status]
+        end
+
+        def code
+          attrs[:code]
+        end
+
+        def title
+          attrs[:title]
+        end
+
+        def detail
+          attrs[:detail]
+        end
+
+        def source_parameter
+          source.fetch(:parameter) do
+            source[:pointer] ? source[:pointer].split('/').last : nil
+          end
+        end
+
+        def source_pointer
+          source.fetch(:pointer) do
+            source[:parameter] ? "/data/attributes/#{source[:parameter]}" : nil
+          end
+        end
+
+        def source
+          res = attrs.fetch(:source, {})
+          res ? res : {}
+        end
+
+        protected
+
+        attr_reader :attrs
+      end
+    end
+  end
+end

data/lib/served/serializers/json_api/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Served
+  module Serializers
+    module JsonApi
+      # Wraps all error objects
+      class Errors < Served::Error
+        include Enumerable
+        attr_reader :errors
+
+        def initialize(response)
+          errors_hash = JSON.parse(response.body)
+          @errors = errors_hash['errors'].map { |error| Error.new(error) }
+        rescue JSON::ParserError
+          @errors = [Error.new(status: response.code, title: 'Parsing Error',
+                               detail: 'Service responded with an unparsable body')]
+        end
+
+        def each(&block)
+          errors.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/served/serializers/json_api.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Served
+  module Serializers
+    # JSON API serializing
+    module JsonApi
+      def self.load(_resource, response)
+        if (200..299).cover?(response.code)
+          data = JSON.parse(response.body)['data']
+          included = JSON.parse(response.body)['included']
+          if data.is_a?(Array)
+            data.map { |d| normalize_and_restructure(d, included) }
+          else
+            normalize_and_restructure(data, included)
+          end
+        else
+          Served::Serializers::JsonApi::Errors.new(response)
+        end
+      end
+
+      def self.parse_errors(result, resource)
+        result.each do |error|
+          if error.source_parameter && resource.attributes.keys.include?(error.source_parameter.to_sym)
+            resource.errors.add(error.source_parameter.to_sym, error_message(error))
+          else
+            resource.errors.add(:base, error_message(error))
+          end
+        end
+        resource
+      end
+
+      # Fetches the error message from either detail or title
+      # if both are nil a custom message is returned
+      def self.error_message(error)
+        error.detail || error.title || 'Error, but no error message found'
+      end
+
+      def self.normalize_and_restructure(data, included)
+        data = normalize_keys(data)
+        attributes = restructure_json(data)
+        merge_relationships(attributes, data, included) if data['relationships']
+        attributes
+      end
+
+      def self.dump(_resource, attributes)
+        attributes.to_json
+      end
+
+      def self.normalize_keys(params)
+        case params
+        when Hash
+          Hash[params.map { |k, v| [k.to_s.tr('-', '_'), normalize_keys(v)] }]
+        when Array
+          params.map { |v| normalize_keys(v) }
+        else
+          params
+        end
+      end
+
+      def self.serialize_individual_error(error)
+        {
+          json_api: error[:title],
+          exception: error[:detail],
+          backtrace: error[:source],
+          code: error[:code]
+        }
+      end
+
+      def self.merge_relationships(restructured, data, included)
+        data['relationships'].keys.each do |relationship|
+          rel = data['relationships'][relationship]
+          next unless rel && rel['data']
+          rel_data = rel['data']
+
+          relationship_attributes = if rel_data.is_a?(Array)
+                                      rel_data.inject([]) { |ary, r| ary << restructure_relationship(r, included) }
+                                    else
+                                      restructure_relationship(rel_data, included)
+                                    end
+          restructured.merge!(relationship => relationship_attributes)
+        end
+        restructured
+      end
+
+      # Restructure JSON API structure into parseable hash
+      def self.restructure_json(data)
+        data['attributes'].merge('id' => data['id'])
+      end
+
+      def self.restructure_relationship(resource, included)
+        relationship = included.find {|r| resource['id'] == r['id'] && resource['type'] == r['type']}
+        relationship['attributes'].merge('id' => resource['id']) if relationship
+      end
+    end
+  end
+end

data/lib/served/serializers/serialization_error.rb

@@ -0,0 +1,11 @@
+module Served
+  module Serializers
+    class SerializationError < Served::Error
+
+      def initialize(original_exception)
+        super("Failed to serialize object with error: '#{original_exception.message}'")
+      end
+
+    end
+  end
+end

data/lib/served/serializers.rb

@@ -0,0 +1,3 @@
+require_relative 'serializers/serialization_error'
+require_relative 'serializers/json'
+require_relative 'serializers/json_api'

data/lib/served/version.rb

@@ -1,3 +1,3 @@
 module Served
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/lib/served.rb

@@ -3,6 +3,7 @@ require 'active_support/core_ext/string'
 require 'active_support/core_ext/module'
 require 'active_model'
 
+require 'served/error'
 require 'served/engine'
 require 'served/version'
 require 'served/config'
@@ -10,6 +11,7 @@ require 'served/backends'
 require 'served/http_client'
 require 'served/resource'
 require 'served/attribute'
+require 'served/serializers'
 
-
-
+require 'served/serializers/json_api/error'
+require 'served/serializers/json_api/errors'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: served
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Jarod Reid
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -169,13 +169,25 @@ files:
 - lib/served/backends/patron.rb
 - lib/served/config.rb
 - lib/served/engine.rb
+- lib/served/error.rb
 - lib/served/http_client.rb
 - lib/served/resource.rb
 - lib/served/resource/attributable.rb
 - lib/served/resource/base.rb
 - lib/served/resource/configurable.rb
+- lib/served/resource/http_errors.rb
+- lib/served/resource/invalid_attribute_serializer.rb
+- lib/served/resource/requestable.rb
+- lib/served/resource/resource_invalid.rb
+- lib/served/resource/response_invalid.rb
 - lib/served/resource/serializable.rb
 - lib/served/resource/validatable.rb
+- lib/served/serializers.rb
+- lib/served/serializers/json.rb
+- lib/served/serializers/json_api.rb
+- lib/served/serializers/json_api/error.rb
+- lib/served/serializers/json_api/errors.rb
+- lib/served/serializers/serialization_error.rb
 - lib/served/version.rb
 - served.gemspec
 homepage: http://github.com/fugufish/served