http_api_tools 0.3.0

data/lib/http_api_tools/model/has_many_array.rb

@@ -0,0 +1,47 @@
+module HttpApiTools
+  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/http_api_tools/model/transformers/date_time_transformer.rb

@@ -0,0 +1,31 @@
+require 'date'
+
+module HttpApiTools
+  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/http_api_tools/model/transformers/registry.rb

@@ -0,0 +1,55 @@
+require_relative 'date_time_transformer'
+require 'singleton'
+
+module HttpApiTools
+  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/http_api_tools/model.rb

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

data/lib/http_api_tools/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 HttpApiTools
+  module Nesting
+    module JsonSerializer
+
+      include HttpApiTools::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/http_api_tools/nesting/relation_loader.rb

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

data/lib/http_api_tools/relation_includes.rb

@@ -0,0 +1,146 @@
+require 'active_support/core_ext'
+require 'http_api_tools/expanded_relation_includes'
+
+# Hopefully the spec is robust enough thttp_api_tools 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 HttpApiTools
+  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
+
+    #Return an expanded version of the includes for use in a query.
+    #This api is still pretty rough and likely to change
+    def for_query(serializer_class)
+      RelationIncludes.new(*ExpandedRelationIncludes.new(self, serializer_class))
+    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/http_api_tools/serializer_registry.rb

@@ -0,0 +1,27 @@
+require 'singleton'
+
+module HttpApiTools
+  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