restpack_serializer 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d630f81aa18ba33e9cea0f4be8a9b4961e8bb3a
-  data.tar.gz: 1ae79679953b1dbb650265bce1ea8ca2e18ae79c
+  metadata.gz: d39e57d828f7ab0187a771d4ab43da44a92da1d1
+  data.tar.gz: c119977625b408dfd76a740b3e5cb8d87b9be867
 SHA512:
-  metadata.gz: 6fcf8116491a31723644f4107335eaf78c8afacff3b4923a9aa2e6b10421d3182b7db307c302a50619ca85ec314e55e9dba12c0dcb2c7d293782b6c37990d18f
-  data.tar.gz: 9d27e0d8341b5c650dcb53efdec3737e32e270ab64d8fe5e82d0945e5a8d51a0003f3b5ac7752474b42c9e47d0a4aa6973e3d865811f9a9609f0084f79c58fe5
+  metadata.gz: e271bc108f3d4596c46a8c4e59e724b55936861fa9f7ba0d6e2557c68e955e3b426bfd38e95f4bb30fe27f3d65907bdef31bacc0a93528d6208eb810cfa0acf0
+  data.tar.gz: 11861d3dd864bb37279d4a5afd410ed6b7a6758ebb5824e578964c9b75f40dac400fd2a0a0fb09be6ee298b849ece4fa2a8791ac76746e7090b32c75165b33f1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Gavin Joyce and RestPack contributors.
+Copyright (c) 2013 Gavin Joyce
 Copyright (c) 2011-2012 José Valim & Yehuda Katz (https://github.com/rails-api/active_model_serializers/blob/master/MIT-LICENSE.txt)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -17,4 +17,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

data/lib/restpack_serializer/factory.rb

@@ -7,10 +7,12 @@ class RestPack::Serializer::Factory
   private
 
   def self.classify(identifier)
-    begin
-      "#{identifier}Serializer".classify.constantize.new
-    rescue
-      "#{identifier.to_s.singularize.to_sym}Serializer".classify.constantize.new
+    normalised_identifier = identifier.to_s.downcase
+    [normalised_identifier, normalised_identifier.singularize].each do |format|
+      klass = RestPack::Serializer.class_map[format]
+      return klass.new if klass
     end
+
+    raise "Invalid RestPack::Serializer : #{identifier}"
   end
 end

data/lib/restpack_serializer/serializable.rb

@@ -8,6 +8,14 @@ require_relative "serializable/side_loading"
 module RestPack
   module Serializer
     extend ActiveSupport::Concern
+    mattr_accessor :class_map
+    @@class_map ||= {}
+
+    included do
+      identifier = self.to_s.downcase.chomp('serializer')
+      @@class_map[identifier] = self
+      @@class_map[identifier.split('::').last] = self
+    end
 
     include RestPack::Serializer::Paging
     include RestPack::Serializer::Resource

data/lib/restpack_serializer/version.rb

@@ -1,5 +1,5 @@
 module RestPack
   module Serializer
-    VERSION = '0.4.2'
+    VERSION = '0.4.3'
   end
 end

data/spec/factory/factory_spec.rb

@@ -4,25 +4,25 @@ describe RestPack::Serializer::Factory do
   let(:factory) { RestPack::Serializer::Factory }
 
   it "creates by string" do
-    factory.create("Song").should be_an_instance_of(SongSerializer)
+    factory.create("Song").should be_an_instance_of(MyApp::SongSerializer)
   end
   it "creates by lowercase string" do
-    factory.create("song").should be_an_instance_of(SongSerializer)
+    factory.create("song").should be_an_instance_of(MyApp::SongSerializer)
   end
   it "creates by lowercase plural string" do
-    factory.create("songs").should be_an_instance_of(SongSerializer)
+    factory.create("songs").should be_an_instance_of(MyApp::SongSerializer)
   end
   it "creates by symbol" do
-    factory.create(:song).should be_an_instance_of(SongSerializer)
+    factory.create(:song).should be_an_instance_of(MyApp::SongSerializer)
   end
   it "creates by class" do
-    factory.create(Song).should be_an_instance_of(SongSerializer)
+    factory.create(MyApp::Song).should 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(SongSerializer)
-    serializers[1].should be_an_instance_of(ArtistSerializer)
-    serializers[2].should be_an_instance_of(AlbumSerializer)
+    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)
   end
 end

data/spec/fixtures/db.rb

@@ -39,31 +39,33 @@ ActiveRecord::Schema.define(:version => 1) do
   end
 end
 
-class Artist < ActiveRecord::Base
-  attr_accessible :name, :website
+module MyApp
+  class Artist < ActiveRecord::Base
+    attr_accessible :name, :website
 
-  has_many :albums
-  has_many :songs
-  has_many :payments
-end
+    has_many :albums
+    has_many :songs
+    has_many :payments
+  end
 
-class Album < ActiveRecord::Base
-  attr_accessible :title, :year, :artist
-  scope :classic, where("year < 1950")
+  class Album < ActiveRecord::Base
+    attr_accessible :title, :year, :artist
+    scope :classic, where("year < 1950")
 
-  belongs_to :artist
-  has_many :songs
-end
+    belongs_to :artist
+    has_many :songs
+  end
 
-class Song < ActiveRecord::Base
-  attr_accessible :title, :artist, :album
+  class Song < ActiveRecord::Base
+    attr_accessible :title, :artist, :album
 
-  belongs_to :artist
-  belongs_to :album
-end
+    belongs_to :artist
+    belongs_to :album
+  end
 
-class Payment < ActiveRecord::Base
-  attr_accessible :amount, :artist
+  class Payment < ActiveRecord::Base
+    attr_accessible :amount, :artist
 
-  belongs_to :artist
+    belongs_to :artist
+  end
 end

data/spec/fixtures/serializers.rb

@@ -1,17 +1,19 @@
-class SongSerializer
-  include RestPack::Serializer
-  attributes :id, :title, :album_id
-  can_include :albums, :artists
-end
+module MyApp
+  class SongSerializer
+    include RestPack::Serializer
+    attributes :id, :title, :album_id
+    can_include :albums, :artists
+  end
 
-class AlbumSerializer
-  include RestPack::Serializer
-  attributes :id, :title, :year, :artist_id
-  can_include :artists, :songs
-end
+  class AlbumSerializer
+    include RestPack::Serializer
+    attributes :id, :title, :year, :artist_id
+    can_include :artists, :songs
+  end
 
-class ArtistSerializer
-  include RestPack::Serializer
-  attributes :id, :name, :website
-  can_include :albums, :songs
+  class ArtistSerializer
+    include RestPack::Serializer
+    attributes :id, :name, :website
+    can_include :albums, :songs
+  end
 end

data/spec/serializable/options_spec.rb

@@ -1,17 +1,17 @@
 require './spec/spec_helper'
 
 describe RestPack::Serializer::Options do
-  let(:subject) { RestPack::Serializer::Options.new(SongSerializer, params, scope) }
+  let(:subject) { RestPack::Serializer::Options.new(MyApp::SongSerializer, params, scope) }
   let(:params) { {} }
   let(:scope) { nil }
 
   describe 'default values' do
-    it { subject.model_class.should == Song }
+    it { subject.model_class.should == MyApp::Song }
     it { subject.includes.should == [] }
     it { subject.page.should == 1 }
     it { subject.page_size.should == 10 }
     it { subject.filters.should == {} }
-    it { subject.scope.should == Song.all }
+    it { subject.scope.should == MyApp::Song.all }
     it { subject.default_page_size?.should == true }
     it { subject.filters_as_url_params.should == '' }
   end
@@ -61,11 +61,11 @@ describe RestPack::Serializer::Options do
 
   context 'scopes' do
     describe 'with default scope' do
-      it { subject.scope.should == Song.all }
+      it { subject.scope.should == MyApp::Song.all }
     end
 
     describe 'with custom scope' do
-      let(:scope) { Song.where("id >= 100") }
+      let(:scope) { MyApp::Song.where("id >= 100") }
       it { subject.scope.should == scope }
     end
   end

data/spec/serializable/paging_spec.rb

@@ -7,7 +7,7 @@ describe RestPack::Serializer::Paging do
   end
 
   context "#page" do
-    let(:page) { SongSerializer.page(params) }
+    let(:page) { MyApp::SongSerializer.page(params) }
     let(:params) { { } }
 
     context "with defaults" do
@@ -46,7 +46,7 @@ describe RestPack::Serializer::Paging do
     end
 
     it "serializes results" do
-      first = Song.first
+      first = MyApp::Song.first
       page[:songs].first.should == {
         id: first.id.to_s,
         title: first.title,
@@ -145,8 +145,8 @@ describe RestPack::Serializer::Paging do
         FactoryGirl.create(:album, year: 1930)
         FactoryGirl.create(:album, year: 1948)
       end
-      let(:page) { AlbumSerializer.page(params, scope) }
-      let(:scope) { Album.classic }
+      let(:page) { MyApp::AlbumSerializer.page(params, scope) }
+      let(:scope) { MyApp::Album.classic }
 
       it "returns a page of scoped data" do
         page[:meta][:albums][:count].should == 2
@@ -155,9 +155,9 @@ describe RestPack::Serializer::Paging do
   end
 
   context "#page_with_options" do
-    let(:page) { SongSerializer.page_with_options(options) }
+    let(:page) { MyApp::SongSerializer.page_with_options(options) }
     let(:params) { {} }
-    let(:options) { RestPack::Serializer::Options.new(SongSerializer, params) }
+    let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, params) }
 
     context "with defaults" do
       it "includes valid paging meta data" do
@@ -178,8 +178,8 @@ describe RestPack::Serializer::Paging do
   end
 
   context "paging with paged side-load" do
-    let(:page) { AlbumSerializer.page_with_options(options) }
-    let(:options) { RestPack::Serializer::Options.new(AlbumSerializer, { includes: 'songs' }) }
+    let(:page) { MyApp::AlbumSerializer.page_with_options(options) }
+    let(:options) { RestPack::Serializer::Options.new(MyApp::AlbumSerializer, { includes: 'songs' }) }
 
     it "includes side-loaded paging data in meta data" do
       page[:meta][:albums].should_not == nil
@@ -190,8 +190,8 @@ describe RestPack::Serializer::Paging do
   end
 
   context "paging with two paged side-loads" do
-    let(:page) { ArtistSerializer.page_with_options(options) }
-    let(:options) { RestPack::Serializer::Options.new(ArtistSerializer, { includes: 'albums,songs' }) }
+    let(:page) { MyApp::ArtistSerializer.page_with_options(options) }
+    let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { includes: 'albums,songs' }) }
 
     it "includes side-loaded paging data in meta data" do
       page[:meta][:albums].should_not == nil

data/spec/serializable/resource_spec.rb

@@ -6,7 +6,7 @@ describe RestPack::Serializer::Resource do
     @song = @album.songs.first
   end
 
-  let(:resource) { SongSerializer.resource(params) }
+  let(:resource) { MyApp::SongSerializer.resource(params) }
   let(:params) { { id: @song.id.to_s } }
 
   it "returns a resource by id" do
@@ -40,7 +40,7 @@ describe RestPack::Serializer::Resource do
 
   describe "song with no artist" do
     let(:song) { FactoryGirl.create(:song, :artist => nil) }
-    let(:resource) { SongSerializer.resource(id: song.id.to_s) }
+    let(:resource) { MyApp::SongSerializer.resource(id: song.id.to_s) }
 
     it "should not have an artist link" do
       resource[:songs][0][:links].keys.should_not include(:artist)

data/spec/serializable/serializer_spec.rb

@@ -78,7 +78,7 @@ describe RestPack::Serializer do
     end
 
     context "links" do
-      let(:serializer) { SongSerializer.new }
+      let(:serializer) { MyApp::SongSerializer.new }
       it "includes 'links' data" do
         @album1 = FactoryGirl.create(:album_with_songs, song_count: 11)
         json = serializer.as_json(@album1.songs.first)

data/spec/serializable/side_loading/belongs_to_spec.rb

@@ -8,13 +8,13 @@ describe RestPack::Serializer::SideLoading do
         FactoryGirl.create(:artist_with_albums, album_count: 2)
         FactoryGirl.create(:artist_with_albums, album_count: 1)
       end
-      let(:side_loads) { SongSerializer.side_loads(models, options) }
+      let(:side_loads) { MyApp::SongSerializer.side_loads(models, options) }
 
       context "with no models" do
         let(:models) { [] }
 
         context "no side-loads" do
-          let(:options) { RestPack::Serializer::Options.new(SongSerializer) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer) }
 
           it "returns a hash with no data" do
             side_loads.should == { :meta => {} }
@@ -22,7 +22,7 @@ describe RestPack::Serializer::SideLoading do
         end
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(SongSerializer, { "includes" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "includes" => "albums" }) }
 
           it "returns a hash with no data" do
             side_loads.should == { :meta => {} }
@@ -31,14 +31,14 @@ describe RestPack::Serializer::SideLoading do
       end
 
       context "with a single model" do
-        let(:models) { [Song.first] }
+        let(:models) { [MyApp::Song.first] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(SongSerializer, { "includes" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "includes" => "albums" }) }
 
           it "returns side-loaded albums" do
             side_loads.should == {
-              albums: [AlbumSerializer.as_json(Song.first.album)],
+              albums: [MyApp::AlbumSerializer.as_json(MyApp::Song.first.album)],
               meta: { }
             }
           end
@@ -46,20 +46,20 @@ describe RestPack::Serializer::SideLoading do
       end
 
       context "with multiple models" do
-        let(:artist1) { Artist.find(1) }
-        let(:artist2) { Artist.find(2) }
+        let(:artist1) { MyApp::Artist.find(1) }
+        let(:artist2) { MyApp::Artist.find(2) }
         let(:song1) { artist1.songs.first }
         let(:song2) { artist2.songs.first }
         let(:models) { [song1, song2] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(SongSerializer, { "includes" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::SongSerializer, { "includes" => "albums" }) }
 
           it "returns side-loaded albums" do
             side_loads.should == {
               albums: [
-                AlbumSerializer.as_json(song1.album),
-                AlbumSerializer.as_json(song2.album)
+                MyApp::AlbumSerializer.as_json(song1.album),
+                MyApp::AlbumSerializer.as_json(song2.album)
               ],
               :meta => { }
             }

data/spec/serializable/side_loading/has_many_spec.rb

@@ -8,13 +8,13 @@ describe RestPack::Serializer::SideLoading do
         @artist1 = FactoryGirl.create(:artist_with_albums, album_count: 2)
         @artist2 = FactoryGirl.create(:artist_with_albums, album_count: 1)
       end
-      let(:side_loads) { ArtistSerializer.side_loads(models, options) }
+      let(:side_loads) { MyApp::ArtistSerializer.side_loads(models, options) }
 
       context "with a single model" do
         let(:models) { [@artist1] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(ArtistSerializer, { "includes" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "includes" => "albums" }) }
 
           it "returns side-loaded albums" do
             side_loads[:albums].count.should == @artist1.albums.count
@@ -28,7 +28,7 @@ describe RestPack::Serializer::SideLoading do
         let(:models) { [@artist1, @artist2] }
 
         context "when including :albums" do
-          let(:options) { RestPack::Serializer::Options.new(ArtistSerializer, { "includes" => "albums" }) }
+          let(:options) { RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "includes" => "albums" }) }
 
           it "returns side-loaded albums" do
             expected_count = @artist1.albums.count + @artist2.albums.count

data/spec/serializable/side_loading/side_loading_spec.rb

@@ -9,10 +9,10 @@ describe RestPack::Serializer::SideLoading do
     context "an include to an inexistent model" do
       it "raises an exception" do
         exception = RestPack::Serializer::InvalidInclude
-        message = ":wrong is not a valid include for Song"
+        message = ":wrong is not a valid include for MyApp::Song"
 
         expect do
-          SongSerializer.side_loads([Song.first], RestPack::Serializer::Options.new(SongSerializer, { "includes" => "wrong" }))
+          MyApp::SongSerializer.side_loads([MyApp::Song.first], RestPack::Serializer::Options.new(MyApp::SongSerializer, { "includes" => "wrong" }))
         end.to raise_error(exception, message)
       end
     end
@@ -21,10 +21,10 @@ describe RestPack::Serializer::SideLoading do
       it "raises an exception" do
         payment = FactoryGirl.create(:payment)
         exception = RestPack::Serializer::InvalidInclude
-        message = ":payments is not a valid include for Artist"
+        message = ":payments is not a valid include for MyApp::Artist"
 
         expect do
-          ArtistSerializer.side_loads([payment.artist], RestPack::Serializer::Options.new(ArtistSerializer, { "includes" => "payments" }))
+          MyApp::ArtistSerializer.side_loads([payment.artist], RestPack::Serializer::Options.new(MyApp::ArtistSerializer, { "includes" => "payments" }))
         end.to raise_error(exception, message)
       end
     end
@@ -50,7 +50,7 @@ describe RestPack::Serializer::SideLoading do
   end
 
   describe "#links" do
-    AlbumSerializer.links.should == {
+    MyApp::AlbumSerializer.links.should == {
       "albums.artist" => {
         :href => "/artists/{albums.artist}.json",
         :type => :artists
@@ -64,7 +64,7 @@ describe RestPack::Serializer::SideLoading do
     it "applies custom RestPack::Serializer.config.href_prefix" do
       original = RestPack::Serializer.config.href_prefix
       RestPack::Serializer.config.href_prefix = "/api/v1"
-      AlbumSerializer.links["albums.artist"][:href].should == "/api/v1/artists/{albums.artist}.json"
+      MyApp::AlbumSerializer.links["albums.artist"][:href].should == "/api/v1/artists/{albums.artist}.json"
       RestPack::Serializer.config.href_prefix = original
     end
   end
@@ -72,17 +72,17 @@ describe RestPack::Serializer::SideLoading do
   describe "#filterable_by" do
     context "a model with no :belongs_to relations" do
       it "is filterable by :id only" do
-        ArtistSerializer.filterable_by.should == [:id]
+        MyApp::ArtistSerializer.filterable_by.should == [:id]
       end
     end
     context "a model with a single :belongs_torelations" do
       it "is filterable by primary key and foreign keys" do
-        AlbumSerializer.filterable_by.should =~ [:id, :artist_id]
+        MyApp::AlbumSerializer.filterable_by.should =~ [:id, :artist_id]
       end
     end
     context "a model with multiple :belongs_to relations" do
       it "is filterable by primary key and foreign keys" do
-        SongSerializer.filterable_by.should =~ [:id, :artist_id, :album_id]
+        MyApp::SongSerializer.filterable_by.should =~ [:id, :artist_id, :album_id]
       end
     end
   end

data/spec/support/factory.rb

@@ -1,7 +1,7 @@
   require 'factory_girl'
 
 FactoryGirl.define do
-  factory :artist do
+  factory :artist, :class => MyApp::Artist do
     sequence(:name) {|n| "Artist ##{n}" }
     sequence(:website) {|n| "http://website#{n}.com/" }
 
@@ -16,7 +16,7 @@ FactoryGirl.define do
     end
   end
 
-  factory :album do
+  factory :album, :class => MyApp::Album do
     sequence(:title) {|n| "Album ##{n}" }
     sequence(:year) {|n| 1960 + n }
     artist
@@ -32,14 +32,14 @@ FactoryGirl.define do
     end
   end
 
-  factory :song do
+  factory :song, :class => MyApp::Song do
     sequence(:title) {|n| "Song ##{n}" }
     artist
     album
   end
 
-  factory :payment do
+  factory :payment, :class => MyApp::Payment do
     amount 999
     artist
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restpack_serializer
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Gavin Joyce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-06 00:00:00.000000000 Z
+date: 2013-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -265,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.7
 signing_key: 
 specification_version: 4
 summary: Model serialization, paging, side-loading and filtering