http_api_tools 0.3.0

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new

data/http_api_tools.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_api_tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "http_api_tools"
+  spec.version       = HttpApiTools::VERSION
+  spec.authors       = ["Rob Monie"]
+  spec.email         = ["robmonie@gmail.com"]
+  spec.description   = %q{Http API Tools}
+  spec.summary       = %q{Provides JSON serialization/deserialization and basic model attribute definition for client apps}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "activesupport"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-debugger"
+  spec.add_development_dependency "ruby-prof"
+
+end

data/lib/http_api_tools/base_json_serializer.rb

@@ -0,0 +1,103 @@
+
+require "active_support/core_ext/class/attribute"
+require "active_support/json"
+require 'active_support/core_ext/string/inflections'
+require_relative 'relation_includes'
+require_relative 'identity_map'
+require_relative 'type_key_resolver'
+
+module HttpApiTools
+  module BaseJsonSerializer
+
+    attr_reader :serializable, :relation_includes, :result, :meta_data
+
+    def initialize(serializable, attrs = {})
+      @serializable = serializable
+      @relation_includes = attrs[:relation_includes] || RelationIncludes.new
+      @result = attrs[:result] || {}
+      @meta_data = { type: root_key.to_s.singularize, root_key: root_key.to_s }
+    end
+
+
+    def attribute_hash
+
+      attribute_hash = {}
+
+      attributes.each do |attr_name|
+        if self.respond_to?(attr_name)
+          attribute_hash[attr_name] = self.send(attr_name)
+        else
+          attribute_hash[attr_name] = serializable.send(attr_name)
+        end
+      end
+
+      attribute_hash
+
+    end
+
+
+    def to_json(*args)
+      JSON.fast_generate(as_json)
+    end
+
+    def includes(*includes)
+
+      if includable
+        allowable_includes_to_add = RelationIncludes.new(*includes) & includable
+      else
+        allowable_includes_to_add = includes
+      end
+
+      relation_includes.include(allowable_includes_to_add)
+
+      self
+    end
+
+    def meta(data)
+      meta_data.merge!(data)
+      self
+    end
+
+    def attributes
+      self.class._attributes
+    end
+
+    def has_ones
+      self.class.has_ones
+    end
+
+    def has_manys
+      self.class.has_manys
+    end
+
+    def includable
+      self.class._includable
+    end
+
+    protected
+
+    attr_accessor :identity_map
+
+    private
+
+    attr_writer :relation_includes
+    attr_reader :type_key_resolver
+    attr_accessor :serializer_map, :meta_data
+
+    def root_key
+      @_root_key ||= self.class._serializes.name.split("::").last.underscore.pluralize.to_sym
+    end
+
+    def includes_meta_data
+      {
+        includable: includable.to_s.blank? ? '*' : includable.to_s,
+        included: relation_includes.to_s
+      }
+    end
+
+    def assert_id_present(serializable_item)
+      raise "serializable items must have an id attribute" unless serializable_item.respond_to?(:id)
+    end
+
+  end
+end

data/lib/http_api_tools/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 HttpApiTools
+  class ExpandedRelationIncludes
+
+    def initialize(relation_includes, serializer_class)
+      @relation_includes = relation_includes
+      @serializer_class = serializer_class
+    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_class, :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/http_api_tools/identity_map.rb

@@ -0,0 +1,42 @@
+#type/id map for mapping string or symbol keys and ids to objects.
+module HttpApiTools
+  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/http_api_tools/json_serializer_dsl.rb

@@ -0,0 +1,62 @@
+require_relative 'serializer_registry'
+
+module HttpApiTools
+  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
+      HttpApiTools::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 == HttpApiTools::Sideloading::JsonSerializer }
+        :sideloading
+      elsif self.ancestors.any? { |klass| klass == HttpApiTools::Nesting::JsonSerializer }
+        :nesting
+      else
+        raise "Unsupported serializer_type. Must be one of either 'sideloading' or 'nesting' serializer."
+      end
+    end
+
+  end
+end

data/lib/http_api_tools/model/acts_like_active_model.rb

@@ -0,0 +1,16 @@
+#Adds methods thttp_api_tools 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 HttpApiTools
+  module Model
+    module ActsLikeActiveModel
+
+      def to_param
+        if self.respond_to?(:id)
+          self.id
+        end
+      end
+    end
+  end
+end

data/lib/http_api_tools/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 HttpApiTools
+  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