http_api_tools 0.3.0

data/lib/http_api_tools/sideloading/json_deserializer.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+#Takes a json response based on the active-model-serializer relationship sideloading pattern
+#and given a root object key, builds an object graph with cyclic relationships.
+#See the id based pattern here - https://github.com/rails-api/active_model_serializers
+require 'active_support/core_ext/hash/indifferent_access'
+require_relative 'sideload_map'
+require_relative '../identity_map'
+
+module HttpApiTools
+  module Sideloading
+    class JsonDeserializer
+
+      def initialize(json)
+        @json = json
+        @root_key = json['meta']['root_key'].to_s
+        @identity_map = IdentityMap.new
+        @sideload_map = SideloadMap.new(json, root_key)
+        @key_to_class_mappings = {}
+      end
+
+      def deserialize
+        json[root_key].map do |json_item|
+          create_from_json_item(target_class_for_key(root_key), json_item)
+        end
+      end
+
+      private
+
+      attr_accessor :json, :root_key, :sideload_map, :identity_map, :key_to_class_mappings
+
+      def create_from_json_item(target_class, json_item)
+
+        return nil unless target_class
+
+        existing_deserialized = identity_map.get(target_class.name, json_item['id'])
+        return existing_deserialized if existing_deserialized
+
+        relations = {}
+        target_class_name = target_class.name
+
+        #we have to add this before we process subtree or we'll get circular issues
+        target = target_class.new(json_item.with_indifferent_access)
+        identity_map.put(target_class_name, json_item['id'], target)
+
+        links = json_item['links'] || {}
+        apply_linked_relations_to_target(target, links)
+
+        target
+
+      end
+
+      def apply_linked_relations_to_target(target, links)
+
+        target_class_name = target.class.name
+
+        links.each do |relation_name, value|
+          if value.kind_of?(Array)
+            target.send("#{relation_name}=", create_has_manys(target_class_name, relation_name, value))
+            target.send("#{relation_name.singularize}_ids=", value)
+          else
+            target.send("#{relation_name}=", create_belongs_to(target_class_name, relation_name, value))
+            target.send("#{relation_name}_id=", value)
+          end
+        end
+      end
+
+      def create_belongs_to(parent_class_name, sideload_key, id)
+
+        sideload_key = mapped_sideload_key_for(parent_class_name, sideload_key)
+
+        if sideloaded_json = sideload_map.get(sideload_key, id)
+          sideloaded_object = create_from_json_item(target_class_for_key(sideload_key), sideloaded_json)
+        else
+          nil
+        end
+      end
+
+      def create_has_manys(parent_class_name, sideload_key, ids)
+        sideload_key = mapped_sideload_key_for(parent_class_name, sideload_key)
+        target_class = target_class_for_key(sideload_key)
+        sideloaded_json_items = sideload_map.get_all(sideload_key, ids)
+
+        sideloaded_json_items.map do |json_item|
+          create_from_json_item(target_class, json_item)
+        end
+      end
+
+      def mapped_sideload_key_for(parent_class_name, sideload_key)
+
+        resolve_class_mappings_for(parent_class_name)
+        class_mapping = key_to_class_mappings[parent_class_name]
+
+        if attribute_mapping = class_mapping[sideload_key.to_sym]
+          return attribute_mapping.name.underscore
+        end
+
+        sideload_key
+      end
+
+      def resolve_class_mappings_for(parent_class_name)
+        unless key_to_class_mappings[parent_class_name]
+          mapping_class_name = "#{parent_class_name}DeserializerMapping"
+          if Object.const_defined?(mapping_class_name)
+            key_to_class_mappings[parent_class_name] = mapping_class_name.constantize.mappings
+          else
+            key_to_class_mappings[parent_class_name] = {}
+          end
+        end
+      end
+
+      def target_class_for_key(key)
+        key.to_s.singularize.camelize.constantize
+      rescue NameError
+        nil
+      end
+
+
+    end
+  end
+end

data/lib/http_api_tools/sideloading/json_deserializer_mapping.rb

@@ -0,0 +1,27 @@
+require "active_support/core_ext/class/attribute"
+
+module HttpApiTools
+  module Sideloading
+    module JsonDeserializerMapping
+
+      #----Module Inclusion
+
+      def self.included(base)
+        base.class_attribute :_mappings
+        base._mappings = {}
+        base.extend(Dsl)
+      end
+
+      module Dsl
+        def map(attr_name, target_class)
+          self._mappings[attr_name] = target_class
+        end
+
+        def mappings
+          self._mappings
+        end
+      end
+
+    end
+  end
+end

data/lib/http_api_tools/sideloading/json_serializer.rb

@@ -0,0 +1,125 @@
+require_relative '../base_json_serializer'
+require_relative '../json_serializer_dsl'
+require_relative 'relation_sideloader'
+
+module HttpApiTools
+  module Sideloading
+    module JsonSerializer
+
+      include HttpApiTools::BaseJsonSerializer
+
+      attr_reader :relation_includes, :result, :attribute_mappings, :has_one_mappings, :has_many_mappings, :cached
+
+      def initialize(serializable, attrs = {})
+        super
+        @identity_map = attrs[:identity_map] || IdentityMap.new
+        @type_key_resolver = attrs[:type_key_resolver] || TypeKeyResolver.new
+      end
+
+      def as_json(*args)
+
+        result[root_key] = []
+
+        Array(serializable).each do |serializable_item|
+          serialize_item_and_cache_relationships(serializable_item)
+        end
+
+        result.merge({ meta: meta_data.merge(includes_meta_data), linked: relation_sideloader.as_json })
+      end
+
+      def as_sideloaded_hash
+        hash = attribute_hash.merge(links: has_one_hash.merge(has_many_hash))
+        relation_sideloader.sideload_relations
+        hash
+      end
+
+      private
+
+      attr_reader :relation_sideloader
+
+      def serialize_item_and_cache_relationships(serializable_item)
+
+        assert_id_present(serializable_item)
+
+        serializer = serializer_for(serializable_item)
+        hashed = { id: serializable_item.id }
+
+        result[root_key] << hashed
+
+        hashed.merge!(serializer.includes(*relation_includes.to_a).as_sideloaded_hash)
+
+      end
+
+      def has_one_hash
+
+        has_one_hash = {}
+
+        has_ones.each do |attr_name|
+
+          id_attr = "#{attr_name}_id"
+
+          #Use id attr if possible as it's cheaper than referencing the object
+          if serializable.respond_to?(id_attr)
+            related_id = serializable.send(id_attr)
+          else
+            related_id = serializable.send(attr_name).try(:id)
+          end
+
+          has_one_hash[attr_name] = related_id
+
+        end
+
+        has_one_hash
+
+      end
+
+
+      def has_many_hash
+
+        has_many_hash = {}
+
+        has_manys.each do |attr_name|
+          has_many_relation = serializable.send(attr_name) || []
+          has_many_hash[attr_name] = has_many_relation.map(&:id)
+        end
+
+        has_many_hash
+
+      end
+
+      def relation_sideloader
+        @relation_sideloader ||= RelationSideloader.new(
+          serializable: serializable,
+          has_ones: has_ones,
+          has_manys: has_manys,
+          relation_includes: relation_includes,
+          identity_map: identity_map,
+          type_key_resolver: type_key_resolver,
+          result: result
+        )
+      end
+
+      def serializer_for(serializable_item)
+
+        serializer_class = serializer_class_for(serializable_item)
+
+        serializer_class.new(serializable_item, {
+          result: result,
+          identity_map: identity_map,
+          type_key_resolver: type_key_resolver
+        })
+
+      end
+
+      def serializer_class_for(serializable)
+        HttpApiTools::SerializerRegistry.instance.get(:sideloading, serializable.class)
+      end
+
+      def self.included(serializer_class)
+        JsonSerializerDsl.apply_to(serializer_class)
+      end
+
+    end
+  end
+end
+

data/lib/http_api_tools/sideloading/relation_sideloader.rb

@@ -0,0 +1,79 @@
+module HttpApiTools
+  module Sideloading
+    class RelationSideloader
+
+      def initialize(opts = {})
+        @serializable = opts[:serializable]
+        @has_ones = opts[:has_ones]
+        @has_manys = opts[:has_manys]
+        @relation_includes = opts[:relation_includes]
+        @result = opts[:result]
+        @identity_map = opts[:identity_map]
+        @type_key_resolver = opts[:type_key_resolver]
+      end
+
+      def sideload_relations
+        sideload_has_ones
+        sideload_has_manys
+      end
+
+      def as_json
+        identity_map.to_hash.inject({}) do |sideload_data, (key, type_map)|
+          sideload_data[key] = type_map.values
+          sideload_data
+        end
+      end
+
+      private
+
+      attr_reader :serializable, :has_ones, :has_manys, :relation_includes, :identity_map, :type_key_resolver, :result
+
+      def sideload_has_ones
+
+        has_ones.each do |attr_name|
+          if related_item = relation_for(attr_name)
+            type_key = type_key_for(related_item)
+            sideload_item(related_item, attr_name, type_key) unless identity_map.get(type_key, related_item.id)
+          end
+        end
+      end
+
+      def sideload_has_manys
+
+        has_manys.each do |attr_name|
+
+          if related_items = relation_for(attr_name)
+            type_key = nil
+            related_items.each do |related_item|
+              type_key ||= type_key_for(related_item)
+              sideload_item(related_item, attr_name, type_key) unless identity_map.get(type_key, related_item.id)
+            end
+          end
+        end
+      end
+
+
+      def relation_for(attr_name)
+        serializable.send(attr_name) if relation_includes.includes_relation?(attr_name)
+      end
+
+      def sideload_item(related, attr_name, type_key)
+        serializer_class = serializer_class_for(related)
+        includes = relation_includes.nested_includes_for(attr_name) || []
+        sideloaded_hash = serializer_class.new(related, { result: result, identity_map: identity_map, type_key_resolver: type_key_resolver }).includes(*includes).as_sideloaded_hash
+
+        identity_map.put(type_key, related.id, sideloaded_hash)
+      end
+
+      def type_key_for(related)
+        type_key_resolver.for_class(related.class)
+      end
+
+      def serializer_class_for(serializable)
+        HttpApiTools::SerializerRegistry.instance.get(:sideloading, serializable.class)
+      end
+
+
+    end
+  end
+end

data/lib/http_api_tools/sideloading/sideload_map.rb

@@ -0,0 +1,54 @@
+require 'active_support/core_ext/string/inflections'
+require 'http_api_tools/identity_map'
+#Holds a fast access map of all sideloaded json for deserialization
+
+module HttpApiTools
+  module Sideloading
+    class SideloadMap
+
+      def initialize(json, root_key)
+
+        @root_key = root_key
+        @identity_map = IdentityMap.new
+
+        build_from_json(json)
+      end
+
+      def get(type, id)
+        identity_map.get(type.singularize, id)
+      end
+
+      def get_all(type, ids)
+        ids.map { |id| get(type, id)}.compact
+      end
+
+      def inspect
+        identity_map.inspect
+      end
+
+      private
+
+      attr_accessor :root_key, :identity_map
+
+
+      def put(type, id, object)
+        identity_map.put(type.singularize, id, object)
+      end
+
+      def build_from_json(json)
+
+        json[root_key].each do |json_item|
+          put(root_key, json_item['id'], json_item)
+        end
+
+        if json['linked']
+          json['linked'].each do |type_key, sideloaded_json_item|
+            sideloaded_json_item.each { |json_item| put(type_key, json_item['id'], json_item) }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_api_tools/type_key_resolver.rb

@@ -0,0 +1,27 @@
+#Provides a cache for resolved type keys against classes. When serializing a lot of
+#relationships this can have a significant improvement on performance.
+
+module HttpApiTools
+  class TypeKeyResolver
+
+    def initialize
+      @cache = {}
+    end
+
+    def for_class(klass)
+      class_name = klass.name
+      cache[class_name] || resolve_and_store_type_key_for(class_name)
+    end
+
+    private
+
+    attr_reader :cache
+
+    def resolve_and_store_type_key_for(class_name)
+      type_key = class_name.underscore.pluralize
+      cache[class_name] = type_key
+      type_key
+    end
+
+  end
+end

data/lib/http_api_tools/version.rb

@@ -0,0 +1,3 @@
+module HttpApiTools
+  VERSION = "0.3.0"
+end

data/lib/http_api_tools.rb

@@ -0,0 +1,10 @@
+require "http_api_tools/version"
+require 'http_api_tools/nesting/json_serializer'
+require 'http_api_tools/sideloading/json_serializer'
+require 'http_api_tools/sideloading/json_deserializer'
+require 'http_api_tools/model'
+require 'http_api_tools/relation_includes'
+
+module HttpApiTools
+  # Your code goes here...
+end