class RubyJsonApiClient::AmsSerializer

Attributes

json_parsing_method[RW]
store[RW]

Public Class Methods

new(options = {}) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 9
def initialize(options = {})
  if options[:json_parsing_method].nil?
    options[:json_parsing_method] = JSON.method(:parse)
  end

  options.each do |(field, value)|
    send("#{field}=", value)
  end
end

Public Instance Methods

_create_model(klass, data) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 68
def _create_model(klass, data)
  model = klass.new(meta: {})

  model.meta[:data] = data

  if data['links']
    model.meta[:links] = data['links']
  end

  data.reduce(model) do |record, (field, value)|
    if klass.has_field?(field.to_sym)
      record.send("#{field}=", value)
    end

    record
  end
end
assert(test, failure_message) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 64
def assert(test, failure_message)
  raise failure_message if !test
end
extract_many(klass, response, key = nil) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 107
def extract_many(klass, response, key = nil)
  key = klass.to_s.underscore if key.nil?
  plural = ActiveSupport::Inflector.pluralize(key)

  data = transform(response)

  assert data[plural],
    "No key #{plural} in json response."

  assert data[plural].is_a?(Array),
    "Key #{plural} should be an array"

  data[plural].reduce([]) do |collection, json|
    collection << _create_model(klass, json)
  end
end
extract_many_relationship(parent, name, options, response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 124
def extract_many_relationship(parent, name, options, response)
  # given response this will find the relationship
  # for ams based apis the relationship will either be
  # 1) in links
  # 2) in sideloaded data
  data = transform(response)
  singular = ActiveSupport::Inflector.singularize(name)
  meta = parent.meta || {}
  meta_links = meta[:links]
  meta_data = meta[:data]

  if meta_links && meta_links[name.to_s]
    extract_many_relationship_from_links(parent, name, options, meta_links[name.to_s])

  elsif data[name.to_s] && meta_data && meta_data["#{singular}_ids"]
    extract_many_relationship_from_sideload(parent, name, options, response)

  else
    []

  end
end
extract_many_relationship_from_sideload(parent, name, options, response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 157
def extract_many_relationship_from_sideload(parent, name, options, response)
  singular = ActiveSupport::Inflector.singularize(name)
  plural = ActiveSupport::Inflector.pluralize(name)
  klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
  klass = ActiveSupport::Inflector.constantize(klass_name)
  meta_data = parent.meta[:data]

  ids = meta_data["#{singular}_ids"]
  idMap = ids.reduce({}) do |map, id|
    map[id] = true
    map
  end

  extract_many(klass, response, plural)
    .select { |record| idMap[record.id] }
end
extract_single(klass, id, response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 86
def extract_single(klass, id, response)
  return nil if response.nil?
  name = klass.to_s.underscore
  data = transform(response)

  assert data[name],
    "No key #{name} in json response."

  assert data[name]['id'],
    "No id included in #{name} json data"

  if id
    # we will allow idless loading, but if an id is given we
    # will try to verify it.
    assert data[name]['id'].to_s == id.to_s,
      "Tried to find #{name} with id #{id}, but got #{name} with id #{data[name]['id']}."
  end

  _create_model(klass, data[name])
end
extract_single_relationship(parent, name, options, response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 174
def extract_single_relationship(parent, name, options, response)
  plural = ActiveSupport::Inflector.pluralize(name)
  data = transform(response)
  meta = parent.meta || {}
  meta_links = meta[:links]
  meta_data = meta[:data]

  if meta_links && meta_links[name.to_s]
    extract_single_relationship_from_links(parent, name, options, meta_links[name.to_s])

  elsif data[plural.to_s] && meta_data && meta_data["#{name}_id"]
    extract_single_relationship_from_sideload(parent, name, options, response)

  else
    nil # nothing found, return nil object

  end
end
extract_single_relationship_from_sideload(parent, name, options, response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 202
def extract_single_relationship_from_sideload(parent, name, options, response)
  plural = ActiveSupport::Inflector.pluralize(name)
  klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
  klass = ActiveSupport::Inflector.constantize(klass_name)
  meta_data = parent.meta[:data]
  id = meta_data["#{name}_id"]

  extract_many(klass, response, plural)
    .detect { |record| record.id == id }
end
to_data(model) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 32
def to_data(model)
  key = model.class.to_s.underscore.downcase
  id_field = model.class._identifier
  data = {}
  data[key] = {}

  # convert fields to json
  model.class.fields.reduce(data[key]) do |result, field|
    result[field] = model.send(field)
    result
  end

  # convert has one relationships to json
  relationships = model.loaded_has_ones || {}
  relationships.reduce(data[key]) do |result, (name, relationship)|
    if relationship.id
      result["#{name}_id"] = relationship.id
    end
    result
  end

  if !model.persisted?
    data[key].delete(id_field) if data[key].has_key?(id_field)
  end

  data
end
to_json(model) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 60
def to_json(model)
  JSON::generate(to_data(model))
end
transform(response) click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 23
def transform(response)
  if transformed[response].nil?
    parsed = @json_parsing_method.call(response)
    transformed[response] = parsed
  end

  transformed[response]
end
transformed() click to toggle source
# File lib/ruby_json_api_client/serializers/ams_serializer.rb, line 19
def transformed
  @transformed ||= {}
end