fast_jsonapi 1.0.16

data/lib/fast_jsonapi/serialization_core.rb

@@ -0,0 +1,111 @@
+require 'active_support/concern'
+
+module FastJsonapi
+  module SerializationCore
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :attributes_to_serialize,
+                      :relationships_to_serialize,
+                      :cachable_relationships_to_serialize,
+                      :uncachable_relationships_to_serialize,
+                      :record_type,
+                      :cache_length,
+                      :cached
+                      :record_type
+      end
+    end
+
+    class_methods do
+      def id_hash(id, record_type)
+        return { id: id.to_s, type: record_type } if id.present?
+      end
+
+      def ids_hash(ids, record_type)
+        return ids.map { |id| id_hash(id, record_type) } if ids.respond_to? :map
+        id_hash(ids, record_type) # ids variable is just a single id here
+      end
+
+      def attributes_hash(record)
+        attributes_hash = {}
+        attributes_to_serialize.each do |key, method_name|
+          attributes_hash[key] = record.send(method_name)
+        end
+        attributes_hash
+      end
+
+      def relationships_hash(record, relationships = nil)
+        relationships_hash = {}
+        relationships = relationships_to_serialize if relationships.nil?
+
+        relationships.each do |_k, relationship|
+          name = relationship[:key]
+          id_method_name = relationship[:id_method_name]
+          record_type = relationship[:record_type]
+          empty_case = relationship[:relationship_type] == :has_many ? [] : nil
+          relationships_hash[name] = {
+            data: ids_hash(record.send(id_method_name), record_type) || empty_case
+          }
+        end
+        relationships_hash
+      end
+
+      def record_hash(record)
+        if cached
+          record_hash = Rails.cache.fetch(record.cache_key, expires_in: cache_length) do
+            record_hash = id_hash(record.id, record_type) || { id: nil, type: record_type }
+            record_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
+            record_hash[:relationships] = {}
+            record_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize) if cachable_relationships_to_serialize.present?
+            record_hash
+          end
+          record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize)) if uncachable_relationships_to_serialize.present?
+          record_hash
+        else
+          record_hash = id_hash(record.id, record_type) || { id: nil, type: record_type }
+          record_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
+          record_hash[:relationships] = relationships_hash(record) if relationships_to_serialize.present?
+          record_hash
+        end
+      end
+
+      def to_json(payload)
+        MultiJson.dump(payload) if payload.present?
+      end
+
+      # includes handler
+
+      def get_included_records(record, includes_list, known_included_objects)
+        included_records = []
+        includes_list.each do |item|
+          object_method_name = @relationships_to_serialize[item][:object_method_name]
+          record_type = @relationships_to_serialize[item][:record_type]
+          serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
+          relationship_type = @relationships_to_serialize[item][:relationship_type]
+          included_objects = record.send(object_method_name)
+          next if included_objects.blank?
+          included_objects = [included_objects] unless relationship_type == :has_many
+          included_objects.each do |inc_obj|
+            code = "#{record_type}_#{inc_obj.id}"
+            next if known_included_objects.key?(code)
+            known_included_objects[code] = inc_obj
+            included_records << serializer.record_hash(inc_obj)
+          end
+        end
+        included_records
+      end
+
+      def has_permitted_includes(requested_includes)
+        # requested includes should be within relationships defined on serializer
+        allowed_includes = @relationships_to_serialize.keys
+        intersection = allowed_includes & requested_includes
+        if intersection.sort == requested_includes.sort
+          true
+        else
+          raise ArgumentError, "One of keys from #{requested_includes} is not specified as a relationship on the serializer"
+        end
+      end
+    end
+  end
+end

data/spec/lib/extensions/active_record_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'active_record'
+require 'sqlite3'
+
+describe 'active record' do
+
+  # Setup DB
+  before(:all) do
+    @db_file = "test.db"
+
+    # Open a database
+    db = SQLite3::Database.new @db_file
+
+    # Create tables
+    db.execute_batch <<-SQL
+      create table suppliers (
+        name varchar(30),
+        id int primary key
+      );
+
+      create table accounts (
+        name varchar(30),
+        id int primary key,
+        supplier_id int,
+        FOREIGN KEY (supplier_id) REFERENCES suppliers(id)
+      );
+    SQL
+
+    # Insert records
+    @account_id = 2
+    @supplier_id = 1
+    db.execute_batch <<-SQL
+      insert into suppliers values ('Supplier1', #{@supplier_id});
+      insert into accounts values ('Dollar Account', #{@account_id}, #{@supplier_id});
+    SQL
+  end
+
+  # Setup Active Record
+  before(:all) do
+    class Supplier < ActiveRecord::Base
+      has_one :account
+    end
+
+    class Account < ActiveRecord::Base
+      belongs_to :supplier
+    end
+
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'sqlite3',
+      :database  => @db_file
+    )
+  end
+
+  context 'has one patch' do
+
+    it 'has account_id method for a supplier' do
+      expect(Supplier.first.respond_to?(:account_id)).to be true
+      expect(Supplier.first.account_id).to eq @account_id
+    end
+
+  end
+
+  # Clean up DB
+  after(:all) do
+    File.delete(@db_file) if File.exists?(@db_file)
+  end
+end

data/spec/lib/object_serializer_caching_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+
+  context 'when caching has_many' do
+    before(:each) do
+      rails = OpenStruct.new
+      rails.cache = ActiveSupport::Cache::MemoryStore.new
+      stub_const('Rails', rails)
+    end
+
+    it 'returns correct hash when serializable_hash is called' do
+      options = {}
+      options[:meta] = { total: 2 }
+      options[:include] = [:actors]
+      serializable_hash = CachingMovieSerializer.new([movie, movie], options).serializable_hash
+
+      expect(serializable_hash[:data].length).to eq 2
+      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:attributes].length).to eq 2
+
+      expect(serializable_hash[:meta]).to be_instance_of(Hash)
+
+      expect(serializable_hash[:included]).to be_instance_of(Array)
+      expect(serializable_hash[:included][0]).to be_instance_of(Hash)
+      expect(serializable_hash[:included].length).to eq 3
+
+      serializable_hash = CachingMovieSerializer.new(movie).serializable_hash
+
+      expect(serializable_hash[:data]).to be_instance_of(Hash)
+      expect(serializable_hash[:meta]).to be nil
+      expect(serializable_hash[:included]).to be nil
+    end
+
+    it 'uses cached values for the record' do
+      previous_name = movie.name
+      previous_actors = movie.actors
+      CachingMovieSerializer.new(movie).serializable_hash
+
+      movie.name = 'should not match'
+      allow(movie).to receive(:actor_ids).and_return([99])
+
+      expect(previous_name).not_to eq(movie.name)
+      expect(previous_actors).not_to eq(movie.actors)
+      serializable_hash = CachingMovieSerializer.new(movie).serializable_hash
+
+      expect(serializable_hash[:data][:attributes][:name]).to eq(previous_name)
+      expect(serializable_hash[:data][:relationships][:actors][:data].length).to eq movie.actors.length
+    end
+
+    it 'uses cached values for has many as specified' do
+      previous_name = movie.name
+      previous_actors = movie.actors
+      CachingMovieWithHasManySerializer.new(movie).serializable_hash
+
+      movie.name = 'should not match'
+      allow(movie).to receive(:actor_ids).and_return([99])
+
+      expect(previous_name).not_to eq(movie.name)
+      expect(previous_actors).not_to eq(movie.actors)
+      serializable_hash = CachingMovieWithHasManySerializer.new(movie).serializable_hash
+
+      expect(serializable_hash[:data][:attributes][:name]).to eq(previous_name)
+      expect(serializable_hash[:data][:relationships][:actors][:data].length).to eq previous_actors.length
+    end
+  end
+end

data/spec/lib/object_serializer_class_methods_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+
+  include_context 'movie class'
+
+  context 'when testing class methods of object serializer' do
+
+    before(:example) do
+      MovieSerializer.relationships_to_serialize = {}
+    end
+
+    it 'returns correct relationship hash for a has_many relationship' do
+      MovieSerializer.has_many :roles
+      relationship = MovieSerializer.relationships_to_serialize[:roles]
+      expect(relationship).to be_instance_of(Hash)
+      expect(relationship.keys).to all(be_instance_of(Symbol))
+      expect(relationship[:id_method_name]).to end_with '_ids'
+      expect(relationship[:record_type]).to eq 'roles'.singularize.to_sym
+    end
+
+    it 'returns correct relationship hash for a has_many relationship with overrides' do
+      MovieSerializer.has_many :roles, id_method_name: :roles_only_ids, record_type: :super_role
+      relationship = MovieSerializer.relationships_to_serialize[:roles]
+      expect(relationship[:id_method_name]).to be :roles_only_ids
+      expect(relationship[:record_type]).to be :super_role
+    end
+
+    it 'returns correct relationship hash for a belongs_to relationship' do
+      MovieSerializer.belongs_to :area
+      relationship = MovieSerializer.relationships_to_serialize[:area]
+      expect(relationship).to be_instance_of(Hash)
+      expect(relationship.keys).to all(be_instance_of(Symbol))
+      expect(relationship[:id_method_name]).to end_with '_id'
+      expect(relationship[:record_type]).to eq 'area'.singularize.to_sym
+    end
+
+    it 'returns correct relationship hash for a belongs_to relationship with overrides' do
+      MovieSerializer.has_many :area, id_method_name: :blah_id, record_type: :awesome_area, serializer: :my_area
+      relationship = MovieSerializer.relationships_to_serialize[:area]
+      expect(relationship[:id_method_name]).to be :blah_id
+      expect(relationship[:record_type]).to be :awesome_area
+      expect(relationship[:serializer]).to be :MyAreaSerializer
+    end
+
+    it 'returns correct relationship hash for a has_one relationship' do
+      MovieSerializer.has_one :area
+      relationship = MovieSerializer.relationships_to_serialize[:area]
+      expect(relationship).to be_instance_of(Hash)
+      expect(relationship.keys).to all(be_instance_of(Symbol))
+      expect(relationship[:id_method_name]).to end_with '_id'
+      expect(relationship[:record_type]).to eq 'area'.singularize.to_sym
+    end
+
+    it 'returns correct relationship hash for a has_one relationship with overrides' do
+      MovieSerializer.has_one :area, id_method_name: :blah_id, record_type: :awesome_area
+      relationship = MovieSerializer.relationships_to_serialize[:area]
+      expect(relationship[:id_method_name]).to be :blah_id
+      expect(relationship[:record_type]).to be :awesome_area
+    end
+
+    it 'returns serializer name correctly with namespaces' do
+      AppName::V1::MovieSerializer.has_many :area, id_method_name: :blah_id
+      relationship = AppName::V1::MovieSerializer.relationships_to_serialize[:area]
+      expect(relationship[:serializer]).to be :'AppName::V1::AreaSerializer'
+    end
+  end
+
+end

data/spec/lib/object_serializer_hyphen_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+  include_context 'ams movie class'
+
+  context 'when using hyphens for word separation in the JSON API members' do
+    it 'returns correct hash when serializable_hash is called' do
+      serializable_hash = HyphenMovieSerializer.new([movie, movie]).serializable_hash
+      expect(serializable_hash[:data].length).to eq 2
+      expect(serializable_hash[:data][0][:relationships].length).to eq 3
+      expect(serializable_hash[:data][0][:relationships]).to have_key('movie-type'.to_sym)
+      expect(serializable_hash[:data][0][:attributes].length).to eq 2
+      expect(serializable_hash[:data][0][:attributes]).to have_key("release-year".to_sym)
+
+      serializable_hash = HyphenMovieSerializer.new(movie_struct).serializable_hash
+      expect(serializable_hash[:data][:relationships].length).to eq 3
+      expect(serializable_hash[:data][:relationships]).to have_key('movie-type'.to_sym)
+      expect(serializable_hash[:data][:attributes].length).to eq 2
+      expect(serializable_hash[:data][:attributes]).to have_key('release-year'.to_sym)
+      expect(serializable_hash[:data][:id]).to eq movie_struct.id.to_s
+    end
+
+    it 'returns same thing as ams' do
+      ams_movie = build_ams_movies(1).first
+      movie = build_movies(1).first
+      our_json = HyphenMovieSerializer.new([movie]).serialized_json
+      ams_json = ActiveModelSerializers::SerializableResource.new([ams_movie], key_transform: :dash).to_json
+      expect(our_json.length).to eq (ams_json.length)
+    end
+
+    it 'returns type hypenated when trying to serializing a class with multiple words' do
+      movie_type = MovieType.new
+      movie_type.id = 3
+      movie_type.name = "x"
+      serializable_hash = HyphenMovieTypeSerializer.new(movie_type).serializable_hash
+      expect(serializable_hash[:data][:type].to_sym).to eq 'movie-type'.to_sym
+    end
+  end
+end

data/spec/lib/object_serializer_performance_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe FastJsonapi::ObjectSerializer do
+  include_context 'movie class'
+  include_context 'ams movie class'
+
+  context 'when testing performance of serialization' do
+    it 'should create a hash of 1000 records in less than 25 ms' do
+      movies = 1000.times.map { |_i| movie }
+      expect { MovieSerializer.new(movies).serializable_hash }.to perform_under(25).ms
+    end
+
+    it 'should serialize 1000 records to jsonapi in less than 30 ms' do
+      movies = 1000.times.map { |_i| movie }
+      expect { MovieSerializer.new(movies).serialized_json }.to perform_under(30).ms
+    end
+
+    it 'should create a hash of 1000 records with includes and meta in less than 75 ms' do
+      count = 1000
+      movies = count.times.map { |_i| movie }
+      options = {}
+      options[:meta] = { total: count }
+      options[:include] = [:actors]
+      expect { MovieSerializer.new(movies, options).serializable_hash }.to perform_under(75).ms
+    end
+
+    it 'should serialize 1000 records to jsonapi with includes and meta in less than 75 ms' do
+      count = 1000
+      movies = count.times.map { |_i| movie }
+      options = {}
+      options[:meta] = { total: count }
+      options[:include] = [:actors]
+      expect { MovieSerializer.new(movies, options).serialized_json }.to perform_under(75).ms
+    end
+  end
+
+  def print_stats(count, ams_time, our_time)
+    format = '%-15s %-10s %s'
+    puts ''
+    puts format(format, 'Serializer', 'Records', 'Time')
+    puts format(format, 'AMS serializer', count, ams_time.round(2).to_s + ' ms')
+    puts format(format, 'Fast serializer', count, our_time.round(2).to_s + ' ms')
+  end
+
+  context 'when comparing with AMS 0.10.x' do
+    [1, 25, 250, 1000].each do |movie_count|
+      speed_factor = 25
+      it "should serialize #{movie_count} records atleast #{speed_factor} times faster than AMS" do
+        ams_movies = build_ams_movies(movie_count)
+        movies = build_movies(movie_count)
+        our_json = nil
+        ams_json = nil
+        our_serializer = MovieSerializer.new(movies)
+        ams_serializer = ActiveModelSerializers::SerializableResource.new(ams_movies)
+        our_time = Benchmark.measure { our_json = our_serializer.serialized_json }.real * 1000
+        ams_time = Benchmark.measure { ams_json = ams_serializer.to_json }.real * 1000
+        print_stats(movie_count, ams_time, our_time)
+        expect(our_json.length).to eq ams_json.length
+        expect { our_serializer.serialized_json }.to perform_faster_than { ams_serializer.to_json }.at_least(speed_factor).times
+      end
+    end
+  end
+
+  context 'when comparing with AMS 0.10.x and with includes and meta' do
+    [1, 25, 250, 1000].each do |movie_count|
+      speed_factor = 25
+      it "should serialize #{movie_count} records atleast #{speed_factor} times faster than AMS" do
+        ams_movies = build_ams_movies(movie_count)
+        movies = build_movies(movie_count)
+        our_json = nil
+        ams_json = nil
+
+        options = {}
+        options[:meta] = { total: movie_count }
+        options[:include] = [:actors, :movie_type]
+
+        our_serializer = MovieSerializer.new(movies, options)
+        ams_serializer = ActiveModelSerializers::SerializableResource.new(ams_movies, include: options[:include], meta: options[:meta])
+        our_time = Benchmark.measure { our_json = our_serializer.serialized_json }.real * 1000
+        ams_time = Benchmark.measure { ams_json = ams_serializer.to_json }.real * 1000
+        print_stats(movie_count, ams_time, our_time)
+        expect(our_json.length).to eq ams_json.length
+        expect { our_serializer.serialized_json }.to perform_faster_than { ams_serializer.to_json }.at_least(speed_factor).times
+      end
+    end
+  end
+end