http-api-tools 0.1.0

data/lib/hat/expanded_relation_includes.rb

@@ -0,0 +1,77 @@
+# Provides an expanded version of includes for use in queries where ids for has_many relationships are
+# going to be referenced such as with the json serializer. Eradicates n+1 issues in these instances.
+module Hat
+  class ExpandedRelationIncludes
+
+    def initialize(relation_includes, serializer)
+      @relation_includes = relation_includes
+      @serializer = serializer
+    end
+
+    def to_a
+      @expanded_includes ||= begin
+        expanded_includes = []
+        expand_includes(serializer.class, relation_includes, expanded_includes)
+        expanded_includes
+      end
+    end
+
+    private
+
+    attr_reader :serializer, :relation_includes
+
+    def expand_includes(target_serializer_class, base_includes, expanded_includes)
+
+      append_has_many_includes(target_serializer_class, base_includes, expanded_includes)
+
+      base_includes.each do |include_item|
+        if include_item.kind_of?(Symbol)
+          expand_includes_for_symbol(include_item, target_serializer_class, expanded_includes)
+        elsif include_item.kind_of?(Hash)
+          expand_includes_for_hash(include_item, target_serializer_class, expanded_includes)
+        end
+      end
+
+    end
+
+    def expand_includes_for_symbol(include_item, target_serializer_class, expanded_includes)
+
+      related_type = target_serializer_class.serializable_type.reflections[include_item].class_name.constantize
+      related_serializer = SerializerRegistry.instance.get(target_serializer_class.serializer_type, related_type)
+      new_nested_includes = []
+
+      append_has_many_includes(related_serializer, [], new_nested_includes)
+
+      if new_nested_includes.empty?
+        expanded_includes << include_item
+      else
+        expanded_includes << { include_item => new_nested_includes }
+      end
+
+    end
+
+    def expand_includes_for_hash(include_item, target_serializer_class, expanded_includes)
+
+      nested_include_key = include_item.keys.first
+      nested_includes = include_item[nested_include_key]
+
+      related_type = target_serializer_class.serializable_type.reflections[nested_include_key].class_name.constantize
+      related_serializer = SerializerRegistry.instance.get(target_serializer_class.serializer_type, related_type)
+      new_nested_includes = []
+
+      expanded_includes << { nested_include_key => new_nested_includes }
+      expand_includes(related_serializer, nested_includes, new_nested_includes)
+
+    end
+
+    def append_has_many_includes(related_serializer, base_includes, expanded_includes)
+
+      related_serializer.has_manys.each do |has_many_attr|
+        expanded_includes << has_many_attr unless RelationIncludes.new(*base_includes).find(has_many_attr)
+      end
+
+    end
+
+
+  end
+end

data/lib/hat/identity_map.rb

@@ -0,0 +1,42 @@
+#type/id map for mapping string or symbol keys and ids to objects.
+module Hat
+  class IdentityMap
+
+    def initialize
+      #Optimised for speed...as tempting as it might be, don't rewrite this to use hash with indifferent access as it is slower.
+      @identity_map = {}
+    end
+
+    def get(type, id)
+      if id_map = identity_map[type.to_sym]
+        id_map[id]
+      end
+    end
+
+    def put(type, id, object)
+
+      type_symbol = type.to_sym
+
+      unless identity_map[type_symbol]
+        identity_map[type_symbol] = {}
+      end
+
+      identity_map[type_symbol][id] = object
+
+      self
+    end
+
+    def to_hash
+      @identity_map
+    end
+
+    def inspect
+      identity_map.inspect
+    end
+
+    private
+
+    attr_accessor :identity_map
+
+  end
+end

data/lib/hat/json_serializer_dsl.rb

@@ -0,0 +1,62 @@
+require_relative 'serializer_registry'
+
+module Hat
+  module JsonSerializerDsl
+
+    def self.apply_to(serializer_class)
+      serializer_class.class_attribute :_attributes
+      serializer_class.class_attribute :_relationships
+      serializer_class.class_attribute :_includable
+      serializer_class.class_attribute :_serializes
+
+      serializer_class._attributes = []
+      serializer_class._relationships = { has_ones: [], has_manys: [] }
+
+      serializer_class.extend(self)
+    end
+
+    def serializes(klass)
+      self._serializes = klass
+      Hat::SerializerRegistry.instance.register(serializer_type, klass, self)
+    end
+
+    def serializable_type
+      self._serializes
+    end
+
+    def has_ones
+      self._relationships[:has_ones]
+    end
+
+    def has_manys
+      self._relationships[:has_manys]
+    end
+
+    def attributes(*args)
+      self._attributes = args
+    end
+
+    def has_one(has_one)
+      self.has_ones << has_one
+    end
+
+    def has_many(has_many)
+      self.has_manys << has_many
+    end
+
+    def includable(*includes)
+      self._includable = RelationIncludes.new(*includes)
+    end
+
+    def serializer_type
+      if self.ancestors.any? { |klass| klass == Hat::Sideloading::JsonSerializer }
+        :sideloading
+      elsif self.ancestors.any? { |klass| klass == Hat::Nesting::JsonSerializer }
+        :nesting
+      else
+        raise "Unsupported serializer_type. Must be one of either 'sideloading' or 'nesting' serializer."
+      end
+    end
+
+  end
+end

data/lib/hat/model/acts_like_active_model.rb

@@ -0,0 +1,16 @@
+#Adds methods that help a client to behave as if it's dealing with an ActiveModel object.
+#Principle of least surprise here - if someone is working in Rails and using a model it should
+#feel normal and they should be able to do all the things the'd do with an active model object except
+#interact with the database.
+module Hat
+  module Model
+    module ActsLikeActiveModel
+
+      def to_param
+        if self.respond_to?(:id)
+          self.id
+        end
+      end
+    end
+  end
+end

data/lib/hat/model/attributes.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+require "active_support/core_ext/class/attribute"
+require 'active_support/core_ext/string/inflections'
+require_relative "transformers/registry"
+require_relative "has_many_array"
+
+#Mix in to PORO to get basic attribute definition with type coercion and defaults.
+#class MyClass
+#  attribute :name
+#  attribute :date, type: :date_time
+#  attribute :tags, default: []
+#
+#NOTE: Be careful of adding default values other than primitives, arrays or basic hashes. Anything more
+#Complex will need to be copied into each object rather than by direct reference - see the way
+#arrays and hashes are handled in the 'default_for' method below.
+module Hat
+  module Model
+    module Attributes
+
+      def initialize(attrs = {})
+
+        attrs = attrs.with_indifferent_access
+
+        attributes.each do |attr_name, attr_options|
+          raw_value = attrs[attr_name] == nil ? default_for(attr_options) : attrs[attr_name]
+          set_raw_value(attr_name, raw_value, true) unless raw_value == nil
+        end
+
+        self.errors = attrs[:errors] || {}
+
+      end
+
+      def attributes
+        self.class._attributes
+      end
+
+      def has_many_changed(has_many_name)
+        send("#{has_many_name.to_s.singularize}_ids=", send(has_many_name).map(&:id).compact)
+      end
+
+      private
+
+      def set_raw_value(attr_name, raw_value, apply_if_read_only = false)
+
+        attr_def = attributes[attr_name]
+        value = transformed_value(attr_def[:type], raw_value)
+
+        if attr_def[:read_only] && apply_if_read_only
+          instance_variable_set("@#{attr_name}", value)
+        elsif
+          self.send("#{attr_name}=", value)
+        end
+      end
+
+      def transformed_value(type, raw_value)
+        if type
+          transformer_registry.from_raw(type, raw_value)
+        else
+          raw_value
+        end
+      end
+
+      def transformer_registry
+        Transformers::Registry.instance
+      end
+
+      #make sure we don't pass references to the same default object to each instance. Copy/dup where appropriate
+      def default_for(options)
+        assert_default_type_valid(options)
+        default = options[:default]
+        if default.kind_of? Array
+          [].concat(default)
+        elsif default.kind_of? Hash
+          default.dup
+        else
+          default
+        end
+      end
+
+      def assert_default_type_valid(options)
+        if options[:default]
+          default_class = options[:default].class
+          unless [Array, Hash, Integer, Float, String].include? default_class
+            raise "Default values of type #{default_class.name} are not supported."
+          end
+        end
+      end
+
+      def set_belongs_to_value(attr_name, value)
+        instance_variable_set("@#{attr_name}", value)
+        send("#{attr_name}_id=", value.try(:id))
+      end
+
+      def set_has_many_value(attr_name, value)
+        instance_variable_set("@#{attr_name}", HasManyArray.new(value, self, attr_name))
+        has_many_changed(attr_name)
+      end
+
+      #----Module Inclusion
+
+      def self.included(base)
+        base.class_attribute :_attributes
+        base._attributes = {}
+        base.extend(ClassMethods)
+        base.send(:attr_accessor, :errors)
+      end
+
+      module ClassMethods
+
+        def attribute(name, options = {})
+          self._attributes[name] = options
+          if options[:read_only]
+            self.send(:attr_reader, name.to_sym)
+          else
+            self.send(:attr_accessor, name.to_sym)
+          end
+        end
+
+        def belongs_to(attr_name, options = {})
+
+          id_attr_name = "#{attr_name}_id"
+          id_setter_method_name = "#{id_attr_name}="
+
+          send(:attr_reader, attr_name)
+          send(:attr_reader, id_attr_name)
+
+          define_method("#{attr_name}=") do |value|
+            set_belongs_to_value(attr_name, value)
+          end
+
+          define_method(id_setter_method_name) do |value|
+            instance_variable_set("@#{id_attr_name}", value)
+          end
+        end
+
+
+        def has_many(attr_name, options = {})
+
+          ids_attr_name = "#{attr_name.to_s.singularize}_ids"
+          id_setter_method_name = "#{ids_attr_name}="
+
+          send(:attr_reader, attr_name)
+          send(:attr_reader, ids_attr_name)
+
+          define_method("#{attr_name}=") do |value|
+            set_has_many_value(attr_name, value)
+          end
+
+          define_method(id_setter_method_name) do |value|
+            instance_variable_set("@#{ids_attr_name}", value)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/hat/model/has_many_array.rb

@@ -0,0 +1,47 @@
+module Hat
+  module Model
+    class HasManyArray < SimpleDelegator
+
+      def initialize(array, owner, key)
+
+        if array.kind_of?(HasManyArray)
+          array = array.target_array
+        end
+
+        super(array)
+
+        @owner = owner
+        @key = key
+      end
+
+      [:<<, :push, :delete, :delete_at].each do |method_name|
+        define_method(method_name) do |arg|
+          target_array.send(method_name, arg)
+          notify_owner
+        end
+      end
+
+      [:clear, :shift].each do |method_name|
+        define_method(method_name) do
+          target_array.send(method_name)
+          notify_owner
+        end
+      end
+
+      protected
+
+      def target_array
+        __getobj__
+      end
+
+      private
+
+      attr_reader :owner, :key
+
+      def notify_owner
+        owner.has_many_changed(self, key)
+      end
+
+    end
+  end
+end

data/lib/hat/model/transformers/date_time_transformer.rb

@@ -0,0 +1,31 @@
+require 'date'
+
+module Hat
+  module Model
+    module Transformers
+      module DateTimeTransformer
+
+        def self.from_raw(value)
+          if value && value.kind_of?(String)
+            ::DateTime.parse(value)
+          elsif value.kind_of?(DateTime) || value.kind_of?(Date) || value.kind_of?(Time)
+            value
+          elsif value == nil
+            nil
+          else
+            raise TransformError, "Cannot transform #{value.class.name} to DateTime"
+          end
+        end
+
+        def self.to_raw(date_time)
+          if date_time
+            date_time.iso8601
+          else
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hat/model/transformers/registry.rb

@@ -0,0 +1,55 @@
+require_relative 'date_time_transformer'
+require 'singleton'
+
+module Hat
+  module Model
+    module Transformers
+      class Registry
+
+        include Singleton
+
+        def from_raw(type, value)
+          if transformer = get(type)
+            transformer.from_raw(value)
+          else
+            value
+          end
+        end
+
+        def to_raw(type, value)
+          if transformer = get(type)
+            transformer.to_raw(value)
+          else
+            value
+          end
+        end
+
+        def get(type)
+          registry[type.to_sym]
+        end
+
+        def register(type, transformer)
+          if existing_transformer = get(type)
+            raise "'#{type}' has already been registered as #{existing_transformer.name}"
+          else
+            registry[type.to_sym] = transformer
+          end
+        end
+
+        private
+
+        def registry
+          @registry ||= {}
+        end
+
+      end
+
+      class TransformError < StandardError ; end
+
+      #Register Common Transformers
+      Registry.instance.register(:date_time, Transformers::DateTimeTransformer)
+
+    end
+  end
+end
+

data/lib/hat/model.rb

@@ -0,0 +1,2 @@
+require_relative "model/attributes"
+require_relative "model/acts_like_active_model"

data/lib/hat/nesting/json_serializer.rb

@@ -0,0 +1,45 @@
+require "active_support/core_ext/class/attribute"
+require "active_support/json"
+require 'active_support/core_ext/string/inflections'
+require_relative '../base_json_serializer'
+require_relative 'relation_loader'
+
+module Hat
+  module Nesting
+    module JsonSerializer
+
+      include Hat::BaseJsonSerializer
+
+      def as_json(*args)
+
+        result[root_key] = Array(serializable).map do |serializable_item|
+          serializer = self.class.new(serializable_item, { result: {} })
+          serializer.includes(*relation_includes).serialize
+        end
+
+        result.merge({ meta: meta_data.merge(includes_meta_data) })
+      end
+
+      def serialize
+        assert_id_present(serializable)
+        attribute_hash.merge(relation_loader.relation_hash)
+      end
+
+      private
+
+      def relation_loader
+        @relation_loader ||= Relationloader.new({
+          serializable: serializable,
+          has_manys: has_manys,
+          has_ones: has_ones,
+          relation_includes: relation_includes
+        })
+      end
+
+      def self.included(serializer_class)
+        JsonSerializerDsl.apply_to(serializer_class)
+      end
+
+    end
+  end
+end

data/lib/hat/nesting/relation_loader.rb

@@ -0,0 +1,89 @@
+module Hat
+  module Nesting
+    class Relationloader
+
+      def initialize(opts = {})
+        @serializable = opts[:serializable]
+        @has_ones = opts[:has_ones]
+        @has_manys = opts[:has_manys]
+        @relation_includes = opts[:relation_includes]
+      end
+
+      def relation_hash
+        has_one_hash.merge(has_many_hash)
+      end
+
+      private
+
+      attr_reader :serializable, :has_ones, :has_manys, :relation_includes
+
+      def has_one_hash
+        has_ones.inject({}) { |has_one_hash, attr_name| serialize_has_one_relation(has_one_hash, attr_name) }
+      end
+
+      def serialize_has_one_relation(has_one_hash, attr_name)
+
+        id_attr = "#{attr_name}_id"
+
+        if related_item = relation_for(attr_name)
+          has_one_hash[attr_name] = serialize_nested_item_with_includes(related_item, includes_for_attr(attr_name))
+        elsif serializable.respond_to?(id_attr)
+          has_one_hash[id_attr] = serializable.send(id_attr)
+        else
+          has_one_hash[id_attr] = serializable.send(attr_name).try(:id)
+        end
+
+        has_one_hash
+
+      end
+
+
+      def has_many_hash
+        has_manys.inject({}) { |has_many_hash, attr_name| serialize_has_many_relations(has_many_hash, attr_name) }
+      end
+
+      def serialize_has_many_relations(has_many_hash, attr_name)
+        if related_items = relation_for(attr_name)
+          has_many_hash[attr_name] = related_items.map do |related_item|
+            serialize_nested_item_with_includes(related_item, includes_for_attr(attr_name))
+          end
+        else
+          has_many_relation = serializable.send(attr_name) || []
+          has_many_hash["#{attr_name.to_s.singularize}_ids"] = has_many_relation.map(&:id)
+        end
+
+        has_many_hash
+
+      end
+
+      def relation_for(attr_name)
+        serializable.send(attr_name) if relation_includes.includes_relation?(attr_name)
+      end
+
+      def serialize_nested_item_with_includes(serializable_item, includes)
+
+        serializer = serializer_for(serializable_item)
+
+        serializer.includes(*includes).serialize
+
+      end
+
+      def includes_for_attr(attr_name)
+        relation_includes.nested_includes_for(attr_name) || []
+      end
+
+      def serializer_for(serializable_item)
+
+        serializer_class_for(serializable_item).new(serializable_item, {
+          result: {}
+        })
+
+      end
+
+      def serializer_class_for(serializable)
+        Hat::SerializerRegistry.instance.get(:nesting, serializable.class)
+      end
+
+    end
+  end
+end