restpack_serializer 0.6.7 → 0.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ec99f158a9e7825b3134792a1ea5ba5efb2a961f
-  data.tar.gz: a33b39771c550f179826c344af688f5d9e84392b
+SHA256:
+  metadata.gz: 29675ee4cb74f76f0f88dfa4ddb86484cfd5fb7c15e5e0a01ccfa2142f1086c4
+  data.tar.gz: f09ca1d697f23127162ebafbb57f502cb53817cee03f34fb38cbd27861921a1b
 SHA512:
-  metadata.gz: 6412ccee09177e52299f3b8bfbfcdefc5f541f18bb3e5ab95ef126ecb178fd8a7f8304e3ceda94c838d30904056727b9e9413b3175e7cfc437a8eb33214aacf7
-  data.tar.gz: 8c2f759aa5ca1fcf1fa4d927e4fb6c156fdabb0a66a1fbc4bce6f9683d944a861d1b2b79107ae9ca8a23e633a6953dc72f25a67cc7c3dbe35f23f7042262a44b
+  metadata.gz: ca2acc1214a42e32f9ccf8aab6617b7a5c914b7d0f21a5fef64152e0130ababb26844a03bf9489e178f5d32ed13e6f5224a48d6f3e0c710a62ae8ffb22ee70ac
+  data.tar.gz: df71b93f4a14adbdde6f953185b4d105d1f8756cff5fa3f8db3f2e8d65630c7ab53a743515600e901053093955fbebccbfa24c63b390984389a24a13f4126576

data/.gitignore

@@ -3,3 +3,4 @@
 tmp
 /coverage
 Gemfile.lock
+/.idea

data/Gemfile

@@ -3,3 +3,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'coveralls', require: false
+gem 'memory_profiler', require: false

data/Rakefile

@@ -4,4 +4,5 @@ RestPack::Gem::Tasks.load_tasks
 desc "Run some performance tests"
 task :perf do
   require_relative 'performance/perf.rb'
+  require_relative 'performance/mem.rb'
 end

data/lib/restpack_serializer.rb

@@ -6,7 +6,7 @@ require_relative 'restpack_serializer/serializable'
 require_relative 'restpack_serializer/factory'
 require_relative 'restpack_serializer/result'
 
-Kaminari::Hooks.init
+Kaminari::Hooks.init if defined?(Kaminari::Hooks)
 
 module RestPack
   module Serializer

data/lib/restpack_serializer/serializable.rb

@@ -34,7 +34,7 @@ module RestPack
     def as_json(model, context = {})
       return if model.nil?
       if model.kind_of?(Array)
-        return model.map { |item| as_json(item, context) }
+        return model.map { |item| self.class.new.as_json(item, context) }
       end
 
       apply_whitelist_and_blacklist(context)
@@ -57,11 +57,15 @@ module RestPack
       end
 
       add_custom_attributes(data)
-      add_links(model, data) unless self.class.associations.empty?
+      add_links(model, data) if self.class.has_associations?
 
       data
     end
 
+    def to_json(model, context = {})
+      as_json(model, context).to_json
+    end
+
     def custom_attributes
       nil
     end
@@ -140,9 +144,13 @@ module RestPack
       end
 
       def has_user_defined_method?(method_name)
-        user_defined_methods = self.user_defined_methods || []
-        return true if user_defined_methods.include?(method_name)
-        return self.superclass.try(:has_user_defined_method?, method_name)
+        if user_defined_methods && user_defined_methods.include?(method_name)
+          true
+        elsif superclass.respond_to?(:has_user_defined_method?)
+          superclass.has_user_defined_method?(method_name)
+        else
+          false
+        end
       end
 
       def memoized_has_user_defined_method?(method_name)
@@ -165,6 +173,10 @@ module RestPack
         new.as_json(model, context)
       end
 
+      def to_json(model, context = {})
+        new.as_json(model, context).to_json
+      end
+
       def serialize(models, context = {})
         models = [models] unless models.kind_of?(Array)
 

data/lib/restpack_serializer/serializable/side_loading.rb

@@ -44,8 +44,12 @@ module RestPack::Serializer::SideLoading
       end
     end
 
+    def has_associations?
+      @can_includes
+    end
+
     def associations
-      return [] unless @can_includes
+      return [] unless has_associations?
       can_includes.map do |include|
         association = association_from_include(include)
         association if supported_association?(association.macro)

data/lib/restpack_serializer/version.rb

@@ -1,5 +1,5 @@
 module RestPack
   module Serializer
-    VERSION = '0.6.7'
+    VERSION = '0.6.12'
   end
 end

data/performance/mem.rb

@@ -0,0 +1,49 @@
+require 'memory_profiler'
+require_relative '../lib/restpack_serializer'
+
+class SimpleSerializer
+  include RestPack::Serializer
+  attributes :id, :title
+end
+
+simple_model = {
+  id: "123",
+  title: 'This is the title',
+}
+
+# warmup
+SimpleSerializer.as_json(simple_model)
+
+report = MemoryProfiler.report do
+  SimpleSerializer.as_json(simple_model)
+end
+
+puts "="*64
+puts "Simple Serializer:"
+puts "="*64
+
+report.pretty_print(detailed_report: false)
+
+class ComplexSerializer
+  include RestPack::Serializer
+
+  attributes :a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o, :p, :q, :r, :s, :t
+end
+
+complex_model = {
+  a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10,
+  k: 11, l: 12, m: 13, n: 14, o: 15, p: 16, q: 17, r: 18, s: 19, t: 20,
+}
+
+# warmup
+ComplexSerializer.as_json(complex_model)
+
+report = MemoryProfiler.report do
+  ComplexSerializer.as_json(complex_model)
+end
+
+puts "="*64
+puts "Complex Serializer:"
+puts "="*64
+
+report.pretty_print(detailed_report: false)

data/restpack_serializer.gemspec

@@ -17,17 +17,16 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'activesupport', ['>= 4.0.3', '< 5.0']
-  gem.add_dependency 'activerecord', ['>= 4.0.3', '< 5.0']
-  gem.add_dependency 'kaminari', '~> 0.16.1'
+  gem.add_dependency 'activesupport', ['>= 4.0.3', '< 6.1']
+  gem.add_dependency 'activerecord', ['>= 4.0.3', '< 6.1']
+  gem.add_dependency 'kaminari', ['>= 0.17.0', '< 2.0']
 
   gem.add_development_dependency 'restpack_gem', '~> 0.0.9'
-  gem.add_development_dependency 'rake', '~> 11.1.2'
-  gem.add_development_dependency 'guard-rspec', '~> 4.6.4'
-  gem.add_development_dependency 'factory_girl', '~> 4.7.0'
-  gem.add_development_dependency 'sqlite3', '~> 1.3.7'
-  gem.add_development_dependency 'database_cleaner', '~> 1.5.3'
+  gem.add_development_dependency 'rake', '~> 11.3'
+  gem.add_development_dependency 'guard-rspec', '~> 4.7'
+  gem.add_development_dependency 'factory_girl', '~> 4.7'
+  gem.add_development_dependency 'sqlite3', '~> 1.3'
+  gem.add_development_dependency 'database_cleaner', '~> 1.5'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'bump'
-  gem.add_development_dependency 'protected_attributes', '~> 1.1.3'
 end

data/spec/factory/factory_spec.rb

@@ -5,45 +5,52 @@ describe RestPack::Serializer::Factory do
 
   describe "single-word" do
     it "creates by string" do
-      factory.create("Song").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("Song")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by lowercase string" do
-      factory.create("song").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("song")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by lowercase plural string" do
-      factory.create("songs").should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create("songs")).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by symbol" do
-      factory.create(:song).should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create(:song)).to be_an_instance_of(MyApp::SongSerializer)
     end
+
     it "creates by class" do
-      factory.create(MyApp::Song).should be_an_instance_of(MyApp::SongSerializer)
+      expect(factory.create(MyApp::Song)).to be_an_instance_of(MyApp::SongSerializer)
     end
 
     it "creates multiple with Array" do
       serializers = factory.create("Song", "artists", :album)
-      serializers[0].should be_an_instance_of(MyApp::SongSerializer)
-      serializers[1].should be_an_instance_of(MyApp::ArtistSerializer)
-      serializers[2].should be_an_instance_of(MyApp::AlbumSerializer)
+      expect(serializers[0]).to be_an_instance_of(MyApp::SongSerializer)
+      expect(serializers[1]).to be_an_instance_of(MyApp::ArtistSerializer)
+      expect(serializers[2]).to be_an_instance_of(MyApp::AlbumSerializer)
     end
   end
 
   describe "multi-word" do
     it "creates multi-word string" do
-      factory.create("AlbumReview").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("AlbumReview")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word lowercase string" do
-      factory.create("album_review").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("album_review")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word lowercase plural string" do
-      factory.create("album_reviews").should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create("album_reviews")).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word symbol" do
-      factory.create(:album_review).should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create(:album_review)).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
+
     it "creates multi-word class" do
-      factory.create(MyApp::AlbumReview).should be_an_instance_of(MyApp::AlbumReviewSerializer)
+      expect(factory.create(MyApp::AlbumReview)).to be_an_instance_of(MyApp::AlbumReviewSerializer)
     end
   end
-
 end

data/spec/fixtures/db.rb

@@ -1,6 +1,5 @@
 require 'sqlite3'
 require 'active_record'
-require 'protected_attributes'
 
 ActiveRecord::Base.establish_connection(
   :adapter => 'sqlite3',
@@ -66,8 +65,6 @@ end
 
 module MyApp
   class Artist < ActiveRecord::Base
-    attr_accessible :name, :website
-
     has_many :albums
     has_many :songs
     has_many :payments
@@ -76,7 +73,6 @@ module MyApp
   end
 
   class Album < ActiveRecord::Base
-    attr_accessible :title, :year, :artist
     scope :classic, -> { where("year < 1950") }
 
     belongs_to :artist
@@ -85,34 +81,27 @@ module MyApp
   end
 
   class AlbumReview < ActiveRecord::Base
-    attr_accessible :message
     belongs_to :album
   end
 
   class Song < ActiveRecord::Base
     default_scope -> { order(id: :asc) }
 
-    attr_accessible :title, :artist, :album
-
     belongs_to :artist
     belongs_to :album
   end
 
   class Payment < ActiveRecord::Base
-    attr_accessible :amount, :artist
-
     belongs_to :artist
     belongs_to :fan
   end
 
   class Fan < ActiveRecord::Base
-    attr_accessible :name
     has_many :payments
     has_many :artists, :through => :albums
   end
 
   class Stalker < ActiveRecord::Base
-    attr_accessible :name
     has_and_belongs_to_many :artists
   end
 end

data/spec/restpack_serializer_spec.rb

@@ -6,8 +6,8 @@ describe RestPack::Serializer do
 
   context "#setup" do
     it "has defaults" do
-      subject.config.href_prefix.should == ''
-      subject.config.page_size.should == 10
+      expect(subject.config.href_prefix).to eq('')
+      expect(subject.config.page_size).to eq(10)
     end
 
     it "can be configured" do
@@ -16,8 +16,8 @@ describe RestPack::Serializer do
         config.page_size = 50
       end
 
-      subject.config.href_prefix.should == '/api/v1'
-      subject.config.page_size.should == 50
+      expect(subject.config.href_prefix).to eq('/api/v1')
+      expect(subject.config.page_size).to eq(50)
     end
   end
 end

data/spec/result_spec.rb

@@ -3,18 +3,19 @@ require 'spec_helper'
 describe RestPack::Serializer::Result do
   context 'a new instance' do
     it 'has defaults' do
-      subject.resources.should == {}
-      subject.meta.should == {}
-      subject.links.should == {}
+      expect(subject.resources).to eq({})
+      expect(subject.meta).to eq({})
+      expect(subject.links).to eq({})
     end
   end
 
   context 'when serializing' do
     let(:result) { subject.serialize }
+
     context 'in jsonapi.org format' do
       context 'an empty result' do
         it 'returns an empty result' do
-          result.should == {}
+          expect(result).to eq({})
         end
       end
 
@@ -26,9 +27,9 @@ describe RestPack::Serializer::Result do
         end
 
         it 'returns correct jsonapi.org format' do
-          result[:albums].should == subject.resources[:albums]
-          result[:meta].should == subject.meta
-          result[:links].should == subject.links
+          expect(result[:albums]).to eq(subject.resources[:albums])
+          expect(result[:meta]).to eq(subject.meta)
+          expect(result[:links]).to eq(subject.links)
         end
       end
 
@@ -43,16 +44,16 @@ describe RestPack::Serializer::Result do
         end
 
         it 'returns correct jsonapi.org format, including injected has_many links' do
-          result[:albums].should == [{ id: '1', name: 'AMOK', links: { songs: ['91'] } }]
-          result[:links].should == subject.links
-          result[:linked][:songs].should == subject.resources[:songs]
+          expect(result[:albums]).to eq([{ id: '1', name: 'AMOK', links: { songs: ['91'] } }])
+          expect(result[:links]).to eq(subject.links)
+          expect(result[:linked][:songs]).to eq(subject.resources[:songs])
         end
 
         it 'includes resources in correct order' do
-          result.keys[0].should == :albums
-          result.keys[1].should == :linked
-          result.keys[2].should == :links
-          result.keys[3].should == :meta
+          expect(result.keys[0]).to eq(:albums)
+          expect(result.keys[1]).to eq(:linked)
+          expect(result.keys[2]).to eq(:links)
+          expect(result.keys[3]).to eq(:meta)
         end
 
         context 'with multiple calls to serialize' do
@@ -62,7 +63,7 @@ describe RestPack::Serializer::Result do
           end
 
           it 'does not create duplicate has_many links' do
-            result[:albums].first[:links][:songs].count.should == 1
+            expect(result[:albums].first[:links][:songs].count).to eq(1)
           end
         end
       end

data/spec/serializable/filterable_spec.rb

@@ -9,6 +9,6 @@ describe RestPack::Serializer::Filterable do
   end
 
   it "captures the specified filters" do
-    CustomSerializer.serializable_filters.should == [:a, :c]
+    expect(CustomSerializer.serializable_filters).to eq([:a, :c])
   end
 end

data/spec/serializable/options_spec.rb

@@ -6,94 +6,99 @@ describe RestPack::Serializer::Options do
   let(:scope) { nil }
 
   describe 'default values' do
-    it { subject.model_class.should == MyApp::Song }
-    it { subject.include.should == [] }
-    it { subject.page.should == 1 }
-    it { subject.page_size.should == 10 }
-    it { subject.filters.should == {} }
-    it { subject.scope.should == MyApp::Song.all }
-    it { subject.default_page_size?.should == true }
-    it { subject.filters_as_url_params.should == '' }
+    it { expect(subject.model_class).to eq(MyApp::Song) }
+    it { expect(subject.include).to eq([]) }
+    it { expect(subject.page).to eq(1) }
+    it { expect(subject.page_size).to eq(10) }
+    it { expect(subject.filters).to eq({}) }
+    it { expect(subject.scope).to eq(MyApp::Song.all) }
+    it { expect(subject.default_page_size?).to eq(true) }
+    it { expect(subject.filters_as_url_params).to eq('') }
   end
 
   describe 'with paging params' do
     let(:params) { { 'page' => '2', 'page_size' => '8' } }
-    it { subject.page.should == 2 }
-    it { subject.page_size.should == 8 }
+    it { expect(subject.page).to eq(2) }
+    it { expect(subject.page_size).to eq(8) }
   end
 
   describe 'with include' do
     let(:params) { { 'include' => 'model1,model2' } }
-    it { subject.include.should == ["model1", "model2"] }
+    it { expect(subject.include).to eq(%w(model1 model2)) }
   end
 
   context 'with filters' do
     describe 'with no filter params' do
-      let(:params) { { } }
-      it { subject.filters.should == {} }
+      let(:params) { {} }
+      it { expect(subject.filters).to eq({}) }
     end
+
     describe 'with a primary key with a single value' do
       let(:params) { { 'id' => '142857' } }
-      it { subject.filters.should == { id: ['142857'] } }
-      it { subject.filters_as_url_params.should == 'id=142857' }
+      it { expect(subject.filters).to eq(id: %w(142857)) }
+      it { expect(subject.filters_as_url_params).to eq('id=142857') }
     end
+
     describe 'with a primary key with multiple values' do
       let(:params) { { 'ids' => '42,142857' } }
-      it { subject.filters.should == { id: ['42', '142857'] } }
-      it { subject.filters_as_url_params.should == 'id=42,142857' }
+      it { expect(subject.filters).to eq(id: %w(42 142857)) }
+      it { expect(subject.filters_as_url_params).to eq('id=42,142857') }
     end
+
     describe 'with a foreign key with a single value' do
       let(:params) { { 'album_id' => '789' } }
-      it { subject.filters.should == { album_id: ['789'] } }
-      it { subject.filters_as_url_params.should == 'album_id=789' }
+      it { expect(subject.filters).to eq(album_id: %w(789)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=789') }
     end
+
     describe 'with a foreign key with multiple values' do
       let(:params) { { 'album_id' => '789,678,567' } }
-      it { subject.filters.should == { album_id: ['789', '678', '567'] } }
-      it { subject.filters_as_url_params.should == 'album_id=789,678,567' }
+      it { expect(subject.filters).to eq(album_id: %w(789 678 567)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=789,678,567') }
     end
+
     describe 'with multiple foreign keys' do
       let(:params) { { 'album_id' => '111,222', 'artist_id' => '888,999' } }
-      it { subject.filters.should == { album_id: ['111', '222'], artist_id: ['888', '999'] } }
-      it { subject.filters_as_url_params.should == 'album_id=111,222&artist_id=888,999' }
+      it { expect(subject.filters).to eq(album_id: %w(111 222), artist_id: %w(888 999)) }
+      it { expect(subject.filters_as_url_params).to eq('album_id=111,222&artist_id=888,999') }
     end
   end
 
   context 'with sorting parameters' do
     describe 'with no params' do
-      let(:params) { { } }
-      it { subject.sorting.should == {} }
+      let(:params) { {} }
+      it { expect(subject.sorting).to eq({}) }
     end
     describe 'with a sorting value' do
       let(:params) { { 'sort' => 'Title' } }
-      it { subject.sorting.should == { title: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=title' }
+      it { expect(subject.sorting).to eq(title: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=title') }
     end
     describe 'with a descending sorting value' do
       let(:params) { { 'sort' => '-title' } }
-      it { subject.sorting.should == { title: :desc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title' }
+      it { expect(subject.sorting).to eq(title: :desc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title') }
     end
     describe 'with multiple sorting values' do
       let(:params) { { 'sort' => '-Title,ID' } }
-      it { subject.sorting.should == { title: :desc, id: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title,id' }
+      it { expect(subject.sorting).to eq(title: :desc, id: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title,id') }
     end
     describe 'with a not allowed sorting value' do
       let(:params) { { 'sort' => '-title,album_id,id' } }
-      it { subject.sorting.should == { title: :desc, id: :asc } }
-      it { subject.sorting_as_url_params.should == 'sort=-title,id' }
+      it { expect(subject.sorting).to eq(title: :desc, id: :asc) }
+      it { expect(subject.sorting_as_url_params).to eq('sort=-title,id') }
     end
   end
 
   context 'scopes' do
     describe 'with default scope' do
-      it { subject.scope.should == MyApp::Song.all }
+      it { expect(subject.scope).to eq(MyApp::Song.all) }
     end
 
     describe 'with custom scope' do
       let(:scope) { MyApp::Song.where("id >= 100") }
-      it { subject.scope.should == scope }
+      it { expect(subject.scope).to eq(scope) }
     end
   end
 end