http-api-tools 0.1.0

data/lib/hat/relation_includes.rb

@@ -0,0 +1,140 @@
+require 'active_support/core_ext'
+require 'hat/expanded_relation_includes'
+
+# Hopefully the spec is robust enough that we can
+# break this down and refactor as we go. I'm not
+# happy with the complexity of it, but it's a
+# reasonably complex problem
+# ~ Stu
+
+module Hat
+  class RelationIncludes < SimpleDelegator
+    include Comparable
+
+    def initialize(*includes)
+      @includes = includes.compact
+      super(@includes)
+    end
+
+    def self.from_params(params)
+      from_string(params[:include])
+    end
+
+    def self.from_string(string)
+      return new if string.blank?
+
+      includes_hash = build_hash_from_string(string)
+      new(*flatten(includes_hash))
+    end
+
+    def to_s
+      @to_s ||= begin
+        paths = []
+        includes.each do |item|
+          if item.is_a? Hash
+            stringify_keys(paths, item)
+          else
+            paths << [item]
+          end
+        end
+        paths = paths.map { |p| p.join('.') }
+        paths.sort.join(',')
+      end
+    end
+
+    def &(other_includes)
+      hash = self.class.build_hash_from_string(to_s)
+      other_hash = self.class.build_hash_from_string(other_includes.to_s)
+
+      intersected_paths = (to_s.split(',') & other_includes.to_s.split(','))
+      self.class.from_string(intersected_paths.join(','))
+    end
+
+    def <=>(other_includes)
+      to_s <=> other_includes.to_s
+    end
+
+    def include(additional_includes)
+      includes.concat(additional_includes)
+      self
+    end
+
+    def includes_relation?(attr_name)
+      find(attr_name).present?
+    end
+
+    def find(attr_name)
+      includes.find do |relation|
+        (relation.kind_of?(Symbol) && attr_name == relation) ||
+          (relation.kind_of?(Hash) && relation.keys.include?(attr_name))
+      end
+    end
+
+    def nested_includes_for(attr_name)
+      nested = find(attr_name)
+      if nested.kind_of?(Hash)
+        nested[attr_name]
+      end
+    end
+
+    private
+
+    attr_accessor :includes
+
+    def self.build_hash_from_string(string)
+      includes_hash = {}
+      include_paths = string.split(',').map { |path| path.split('.') }
+
+      include_paths.each do |path|
+        current_hash = includes_hash
+        path.each do |token|
+          current_hash[token] ||= {}
+          current_hash = current_hash[token]
+        end
+      end
+      includes_hash
+    end
+
+    def stringify_keys(top_level_paths, hash, path_attrs = [])
+      current_key = hash.keys.first
+      path_attrs << current_key
+      top_level_paths << path_attrs.dup
+
+      hash[current_key].each do |path_value|
+        if path_value.is_a? Hash
+          path_attrs << stringify_keys(top_level_paths, path_value, path_attrs)
+        else
+          top_level_paths << (path_attrs.dup << path_value)
+        end
+      end
+    end
+
+    # Turns this:
+    #
+    # [ :tags, {images: [:comments]}, {reviews: [:author]} ]
+    #
+    # Into this:
+    #
+    #   {
+    #     tags: {},
+    #     images: {
+    #       comments: {}
+    #     }
+    #     reviews: {}
+    #     }
+    #   }
+    #
+    def self.flatten(hash)
+      result = []
+      hash.each do |k, v|
+        if v.keys.size == 0
+          result << k.to_sym
+        else
+          result << { "#{k}".to_sym => flatten(v) }
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/hat/serializer_registry.rb

@@ -0,0 +1,27 @@
+require 'singleton'
+
+module Hat
+  class SerializerRegistry
+
+    include Singleton
+
+    def get(type, class_name)
+      registry.fetch(type.to_sym, {})[class_name]
+    end
+
+    def register(type, class_name, serializer)
+      if existing_serializer = get(type, class_name)
+        raise "A '#{type}' serializer for '#{class_name}' instances has already been registered as #{existing_serializer.name}"
+      else
+        registry[type.to_sym][class_name] = serializer
+      end
+    end
+
+    private
+
+    def registry
+      @registry ||= { sideloading: {}, nesting: {} }
+    end
+
+  end
+end

data/lib/hat/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 Hat
+  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/hat/sideloading/json_deserializer_mapping.rb

@@ -0,0 +1,27 @@
+require "active_support/core_ext/class/attribute"
+
+module Hat
+  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/hat/sideloading/json_serializer.rb

@@ -0,0 +1,125 @@
+require_relative '../base_json_serializer'
+require_relative '../json_serializer_dsl'
+require_relative 'relation_sideloader'
+
+module Hat
+  module Sideloading
+    module JsonSerializer
+
+      include Hat::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)
+        Hat::SerializerRegistry.instance.get(:sideloading, serializable.class)
+      end
+
+      def self.included(serializer_class)
+        JsonSerializerDsl.apply_to(serializer_class)
+      end
+
+    end
+  end
+end
+

data/lib/hat/sideloading/relation_sideloader.rb

@@ -0,0 +1,79 @@
+module Hat
+  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)
+        Hat::SerializerRegistry.instance.get(:sideloading, serializable.class)
+      end
+
+
+    end
+  end
+end

data/lib/hat/sideloading/sideload_map.rb

@@ -0,0 +1,54 @@
+require 'active_support/core_ext/string/inflections'
+require 'hat/identity_map'
+#Holds a fast access map of all sideloaded json for deserialization
+
+module Hat
+  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/hat/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 Hat
+  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/hat/version.rb

@@ -0,0 +1,3 @@
+module Hat
+  VERSION = "0.1.0"
+end

data/lib/hat.rb

@@ -0,0 +1,9 @@
+require "hat/version"
+require 'hat/sideloading/json_serializer'
+require 'hat/sideloading/json_deserializer'
+require 'hat/model'
+require 'hat/relation_includes'
+
+module Hat
+  # Your code goes here...
+end

data/spec/hat/expanded_relation_includes_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'hat/expanded_relation_includes'
+
+module Hat
+  describe ExpandedRelationIncludes do
+
+    describe "#to_a" do
+
+      let(:serializer) { Hat::Sideloading::PersonSerializer.new(Person.new) }
+      let(:expanded_includes) { ExpandedRelationIncludes.new(includes, serializer) }
+
+      context 'with single-level includes' do
+
+        let(:includes) { [:employer, :skills] }
+
+        it "expands includes to include has_many relationships defined by serializers but not in original includes" do
+          expect(expanded_includes.to_a).to eq([{ employer: [:employees] }, :skills])
+        end
+      end
+
+      context 'with multi-level includes' do
+
+        let(:includes) { [:employer, { skills: [:person] }] }
+
+        it "expands includes to include has_many relationships defined by serializers but not in original includes" do
+          expect(expanded_includes.to_a).to eq([{ employer: [:employees] }, { skills: [{ person: [:skills] }] }])
+        end
+      end
+
+    end
+  end
+end

data/spec/hat/identity_map_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'hat/identity_map'
+
+module Hat
+  describe IdentityMap do
+
+    let(:identity_map) { IdentityMap.new }
+    let(:thing) { 'a thing' }
+
+    describe "putting/getting items" do
+      it "puts and revieves same object with string type key" do
+
+        identity_map.put('thing', 1, thing)
+        expect(identity_map.get('thing', 1)).to eql thing
+      end
+
+      it "puts and revieves same object with symbol type key" do
+        identity_map.put(:thing, 1, thing)
+        expect(identity_map.get(:thing, 1)).to eql thing
+      end
+
+      it "puts and revieves same object with mixed type key" do
+        identity_map.put(:thing, 1, thing)
+        expect(identity_map.get('thing', 1)).to eql thing
+      end
+
+    end
+  end
+  class IdentityMapThing ; end
+end
+