perpetuity 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 1a8e9f40c8e01e35ae70dc25cfed9e6e32eaffa8
-  data.tar.gz: 6115b3220a2c680626351aa1c1bb6626d9da73ed
-SHA512: 
-  metadata.gz: a216fe83851f3a6e7b7a6839fd76733dc4695cd7f73219d2d94b6bb159f111ae370e90f7befe837e460b1f40f5ddee0a05be43d0c5d8c9f9b1e7b428d07827fb
-  data.tar.gz: 015afc0afc78719af382d44610f969b3936204004b57a76fff8bf29069b12997ab47a5ed67d68ac80f4daa7f17f8c66f006cd7da511bf43e454e2705487cc068
+---
+SHA1:
+  metadata.gz: 6e9c3b65a81c55bb4d428f51fb6fabff9b144157
+  data.tar.gz: 26ba0eb66da443557c77b97d25671bb94fcc7626
+SHA512:
+  metadata.gz: 0ec48ea694e54ce58c6b46459db4be816472011fa8a0aae0dffec8c2674703b12eb05c42c4f3c5d5ce429bfe44fdbaffe7acf1792e5719998d5d50155f65f905
+  data.tar.gz: 47be19d80852c9de55be009998949b48348787dbc0705b9b11c776a20e5712cea96aad71775e54a6235a231f9ee236bc929384cbcd2fa276211770a9b852c050

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Version 1.0.1
+
+- Fix bug that broke saving associated objects when declaring the `id` attribute with Virtus.
+
 ## Version 1.0.0
 
 - Invoke identity map when using `mapper.select` and `mapper.find` with a block.

data/lib/perpetuity/data_injectable.rb

@@ -12,7 +12,7 @@ module Perpetuity
     end
 
     def give_id_to object, *args
-      if args.any?
+      unless args.empty?
         inject_attribute object, :id, args.first
       end
     end

data/lib/perpetuity/mapper.rb

@@ -240,11 +240,11 @@ module Perpetuity
     end
 
     def persisted? object
-      object.instance_variable_defined?(:@id)
+      !!id_for(object)
     end
 
     def id_for object
-      object.instance_variable_get(:@id) if persisted?(object)
+      object.instance_variable_get(:@id)
     end
 
     def data_source

data/lib/perpetuity/rails_model.rb

@@ -16,6 +16,14 @@ module Perpetuity
       [to_param] if persisted?
     end
 
+    def model_name
+      self.class.model_name
+    end
+
+    def to_model
+      self
+    end
+
     module ActiveModelish
       def model_name
         self
@@ -52,6 +60,10 @@ module Perpetuity
               .gsub(/(\w)([A-Z])/, '\1 \2')
         end
       end
+
+      def i18n_key
+        name.gsub(/::/, '.').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
     end
   end
 end

data/lib/perpetuity/version.rb

@@ -1,3 +1,3 @@
 module Perpetuity
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/perpetuity.gemspec

@@ -19,5 +19,5 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 2.13"
+  s.add_development_dependency "rspec", "~> 3.0"
 end

data/spec/integration/associations_spec.rb

@@ -14,18 +14,19 @@ describe 'associations with other objects' do
 
   describe 'referenced relationships' do
     let(:creator) { topic_mapper.find(topic_mapper.id_for topic).creator }
-    subject { creator }
 
-    it { should be_a Perpetuity::Reference }
-    its(:klass) { should be User }
-    its(:id) { should be == user_mapper.id_for(user) }
+    it 'stores a reference in the object attribute' do
+      expect(creator).to be_a Perpetuity::Reference
+      expect(creator.klass).to be User
+      expect(creator.id).to eq user_mapper.id_for(user)
+    end
   end
 
   it 'can retrieve a one-to-one association' do
     retrieved_topic = topic_mapper.find(topic_mapper.id_for topic)
 
     topic_mapper.load_association! retrieved_topic, :creator
-    retrieved_topic.creator.name.should eq 'Flump'
+    expect(retrieved_topic.creator.name).to eq 'Flump'
   end
 
   describe 'associations with many objects' do
@@ -44,8 +45,8 @@ describe 'associations with other objects' do
       persisted_book = book_mapper.find(book_mapper.id_for pragprog_book)
       book_mapper.load_association! persisted_book, :authors
 
-      persisted_book.authors.first.name.should be == 'Dave'
-      persisted_book.authors.last.name.should be == 'Andy'
+      expect(persisted_book.authors.first.name).to be == 'Dave'
+      expect(persisted_book.authors.last.name).to be == 'Andy'
     end
 
     it 'can retrieve a many-to-many association' do
@@ -55,7 +56,8 @@ describe 'associations with other objects' do
 
       books = book_mapper.select { |book| book.id.in book_ids }.to_a
       book_mapper.load_association! books, :authors
-      books.map(&:authors).flatten.map(&:name).should include(*%w(Dave Andy Matt Aslak))
+      author_names = books.map(&:authors).flatten.map(&:name)
+      expect(author_names).to include(*%w(Dave Andy Matt Aslak))
     end
 
     it 'does not try dereferencing non-reference objects' do
@@ -68,7 +70,7 @@ describe 'associations with other objects' do
       mapper.insert article
       retrieved = mapper.find(mapper.id_for(article))
       mapper.load_association! retrieved, :author
-      retrieved.author.should == [foo, bar]
+      expect(retrieved.author).to be == [foo, bar]
     end
   end
 
@@ -87,7 +89,7 @@ describe 'associations with other objects' do
       it 'serializes attributes' do
         mapper.insert object
         attr = mapper.find(mapper.id_for object).embedded_attribute
-        attr.should be == [unserializable_object]
+        expect(attr).to be == [unserializable_object]
       end
     end
   end

data/spec/integration/deletion_spec.rb

@@ -25,7 +25,7 @@ describe "deletion" do
     it "should delete all objects of a certain class" do
       Perpetuity[Article].insert Article.new
       Perpetuity[Article].delete_all
-      Perpetuity[Article].count.should eq 0
+      expect(Perpetuity[Article].count).to eq 0
     end
   end
 end

data/spec/integration/enumerable_spec.rb

@@ -13,7 +13,7 @@ describe 'enumerable syntax' do
   end
 
   it 'finds a single object based on criteria' do
-    mapper.find { |a| a.title == foo.title }.should be == foo
+    expect(mapper.find { |a| a.title == foo.title }).to be == foo
   end
 
   context 'excludes objects based on criteria' do
@@ -23,26 +23,26 @@ describe 'enumerable syntax' do
 
     it 'excludes on equality' do
       articles = mapper.reject { |a| a.title == bar.title }.to_a
-      articles.should include foo
-      articles.should_not include bar
+      expect(articles).to include foo
+      expect(articles).not_to include bar
     end
 
     it 'excludes on inequality' do
       articles = mapper.reject { |a| a.published_at <= current_time }.to_a
-      articles.should include bar
-      articles.should_not include foo
+      expect(articles).to include bar
+      expect(articles).not_to include foo
     end
 
     it 'excludes on not-equal' do
       articles = mapper.reject { |a| a.title != foo.title }.to_a
-      articles.should include foo
-      articles.should_not include bar
+      expect(articles).to include foo
+      expect(articles).not_to include bar
     end
 
     it 'excludes on regex match' do
       articles = mapper.reject { |a| a.title =~ /Foo/ }.to_a
-      articles.should include bar
-      articles.should_not include foo
+      expect(articles).to include bar
+      expect(articles).not_to include foo
     end
   end
 end

data/spec/integration/indexing_spec.rb

@@ -30,32 +30,35 @@ describe 'indexing' do
   after { mapper.data_source.drop_collection Object }
 
   it 'adds indexes to database collections/tables' do
-    name_index.attribute.name.should be == :name
+    expect(name_index.attribute.name).to be == :name
   end
 
   it 'verifies that indexes are inactive' do
-    name_index.should be_inactive
+    expect(name_index).to be_inactive
   end
 
   it 'creates indexes' do
     mapper.reindex!
-    mapper.data_source.active_indexes(Object).map do |index|
+    index_names = mapper.data_source.active_indexes(Object).map do |index|
       index.attribute.name.to_s
-    end.should include 'name'
-    name_index.should be_active
+    end
+    expect(index_names).to include 'name'
+    expect(name_index).to be_active
   end
 
   it 'specifies uniqueness of the index' do
-    name_index.should be_unique
+    expect(name_index).to be_unique
   end
 
   it 'removes other indexes' do
     mapper.reindex!
     mapper_without_index = mapper_class_without_index.new
     mapper_without_index.reindex!
-    mapper.data_source.active_indexes(Object).any? do |index|
+    any_indexes = mapper.data_source.active_indexes(Object).any? do |index|
       index.attribute.name.to_s == 'name'
-    end.should be_false
+    end
+
+    expect(any_indexes).to be_falsey
   end
 end
 

data/spec/integration/pagination_spec.rb

@@ -3,25 +3,25 @@ require 'support/test_classes'
 
 describe 'pagination' do
   it 'specifies the page we want' do
-    Perpetuity[Article].all.should respond_to :page
+    expect(Perpetuity[Article].all).to respond_to :page
   end
 
   it 'specify the quantity per page' do
-    Perpetuity[Article].all.should respond_to :per_page
+    expect(Perpetuity[Article].all).to respond_to :per_page
   end
 
   it 'returns an empty set when there is no data for that page' do
     mapper = Perpetuity[Article]
     mapper.delete_all
     data = mapper.all.page(2)
-    data.should be_empty
+    expect(data).to be_empty
   end
 
   it 'specifies per-page quantity' do
     Perpetuity[Article].delete_all
     5.times { |i| Perpetuity[Article].insert Article.new i }
     data = Perpetuity[Article].all.page(3).per_page(2).to_a
-    data.should have(1).item
+    expect(data.size).to be 1
   end
 end
 

data/spec/integration/persistence_spec.rb

@@ -7,28 +7,29 @@ describe 'Persistence' do
 
   it "persists an object" do
     article = Article.new 'I have a title'
-    mapper.serialize article
     expect { mapper.insert article }.to change { mapper.count }.by 1
-    mapper.find(mapper.id_for(article)).title.should eq 'I have a title'
+    expect(
+      mapper.find(mapper.id_for(article)).title
+    ).to eq 'I have a title'
   end
 
   it 'persists multiple objects' do
     mapper.delete_all
     articles = 2.times.map { Article.new(SecureRandom.hex) }
     expect { mapper.insert articles }.to change { mapper.count }.by 2
-    mapper.all.sort(:title).to_a.should == articles.sort_by(&:title)
+    expect(mapper.all.sort(:title).to_a).to be == articles.sort_by(&:title)
   end
 
   it 'returns the id of the persisted object' do
     article = Article.new
-    mapper.insert(article).should eq mapper.id_for(article)
+    expect(mapper.insert(article)).to eq mapper.id_for(article)
   end
 
   it "gives an id to objects" do
     article = Article.new
     mapper.give_id_to article, 1
 
-    mapper.id_for(article).should eq 1
+    expect(mapper.id_for(article)).to eq 1
   end
 
   it 'persists referenced objects if they are not persisted' do
@@ -37,7 +38,7 @@ describe 'Persistence' do
     mapper.insert article
 
     retrieved = mapper.find(mapper.id_for(article))
-    mapper.id_for(retrieved.author).should be == mapper.id_for(article.author)
+    expect(mapper.id_for(retrieved.author)).to be == mapper.id_for(article.author)
   end
 
   it 'persists arrays of referenced objects if they are not persisted' do
@@ -48,7 +49,7 @@ describe 'Persistence' do
     mapper.insert book
 
     first_author = mapper.find(mapper.id_for book).authors.first
-    mapper.id_for(first_author).should be == mapper.id_for(authors.first)
+    expect(mapper.id_for(first_author)).to be == mapper.id_for(authors.first)
   end
 
   describe 'id injection' do
@@ -56,15 +57,15 @@ describe 'Persistence' do
 
     it 'assigns an id to the inserted object' do
       mapper.insert article
-      mapper.id_for(article).should_not be_nil
+      expect(mapper.id_for(article)).not_to be_nil
     end
 
     it "assigns an id using Mapper.first" do
-      mapper.id_for(mapper.first).should_not be_nil
+      expect(mapper.id_for(mapper.first)).not_to be_nil
     end
 
     it 'assigns an id using Mapper.all.first' do
-      mapper.id_for(mapper.all.first).should_not be_nil
+      expect(mapper.id_for(mapper.all.first)).not_to be_nil
     end
   end
 
@@ -74,7 +75,7 @@ describe 'Persistence' do
     it 'persists arrays' do
       article.comments << 1 << 2 << 3
       mapper.insert article
-      mapper.find(mapper.id_for article).comments.should eq [1, 2, 3]
+      expect(mapper.find(mapper.id_for article).comments).to eq [1, 2, 3]
     end
 
     it 'persists arrays with unserializable objects in them' do
@@ -82,8 +83,8 @@ describe 'Persistence' do
       article.comments << comment
       mapper.insert article
       persisted_comment = mapper.find(mapper.id_for article).comments.first
-      persisted_comment.should be_a Comment
-      persisted_comment.body.should eq comment.body
+      expect(persisted_comment).to be_a Comment
+      expect(persisted_comment.body).to eq comment.body
     end
   end
 
@@ -94,7 +95,7 @@ describe 'Persistence' do
 
     it 'saves and retrieves hashes' do
       user_mapper.insert user
-      user_mapper.find(user_mapper.id_for user).name.should be == name_hash
+      expect(user_mapper.find(user_mapper.id_for user).name).to be == name_hash
     end
   end
 
@@ -103,7 +104,7 @@ describe 'Persistence' do
     book = Book.new("My Title #{noise}")
 
     Perpetuity[Book].insert book
-    Perpetuity[Book].id_for(book).should eq "my-title-#{noise}"
+    expect(Perpetuity[Book].id_for(book)).to eq "my-title-#{noise}"
   end
 
   context 'with namespaced classes' do
@@ -114,7 +115,7 @@ describe 'Persistence' do
 
     it 'persists even with colons in the names' do
       mapper.insert person
-      mapper.persisted?(person).should be_true
+      expect(mapper.persisted?(person)).to be_truthy
     end
   end
 end

data/spec/integration/retrieval_spec.rb

@@ -14,9 +14,9 @@ describe "retrieval" do
     mapper.insert article
     retrieved = mapper.find(mapper.id_for article)
 
-    mapper.id_for(retrieved).should be == mapper.id_for(article)
-    retrieved.title.should eq article.title
-    retrieved.body.should eq article.body
+    expect(mapper.id_for(retrieved)).to be == mapper.id_for(article)
+    expect(retrieved.title).to be == article.title
+    expect(retrieved.body).to be == article.body
   end
 
   describe 'sorting' do
@@ -31,25 +31,25 @@ describe "retrieval" do
 
     it 'sorts results' do
       titles = mapper.all.sort(:published_at).map(&:title)
-      titles.should be == %w(First Second Third)
+      expect(titles).to be == %w(First Second Third)
     end
 
     it 'reverse-sorts results' do
       titles = mapper.all.sort(:published_at).reverse.map(&:title)
-      titles.should be == %w(Third Second First)
+      expect(titles).to be == %w(Third Second First)
     end
   end
 
   it 'limits result set' do
     5.times { mapper.insert Article.new }
-    mapper.all.limit(4).to_a.should have(4).items
+    expect(mapper.all.limit(4).to_a.size).to eq 4
   end
 
   it 'counts result set' do
     title = "Foo #{Time.now.to_f}"
     mapper = Perpetuity[Article]
     5.times { mapper.insert Article.new(title) }
-    mapper.count { |article| article.title == title }.should == 5
+    expect(mapper.count { |article| article.title == title }).to be == 5
   end
 
   describe "Array-like syntax" do
@@ -68,57 +68,57 @@ describe "retrieval" do
       it 'selects objects using equality' do
         selected = mapper.select { |article| article.title == 'Published' }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include published_id
-        ids.should_not include draft_id
+        expect(ids).to include published_id
+        expect(ids).not_to include draft_id
       end
 
       it 'selects objects using greater-than' do
         selected = mapper.select { |article| article.published_at < Time.now }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include published_id
-        ids.should_not include draft_id
+        expect(ids).to include published_id
+        expect(ids).not_to include draft_id
       end
 
       it 'selects objects using greater-than-or-equal' do
         selected = mapper.select { |article| article.views >= 3 }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include published_id
-        ids.should_not include draft_id
+        expect(ids).to include published_id
+        expect(ids).not_to include draft_id
       end
 
       it 'selects objects using less-than' do
         selected = mapper.select { |article| article.views < 3 }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include draft_id
-        ids.should_not include published_id
+        expect(ids).to include draft_id
+        expect(ids).not_to include published_id
       end
 
       it 'selects objects using less-than-or-equal' do
         selected = mapper.select { |article| article.views <= 0 }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include draft_id
-        ids.should_not include published_id
+        expect(ids).to include draft_id
+        expect(ids).not_to include published_id
       end
 
       it 'selects objects using inequality' do
         selected = mapper.select { |article| article.title != 'Draft' }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should_not include draft_id
-        ids.should include published_id
+        expect(ids).not_to include draft_id
+        expect(ids).to include published_id
       end
 
       it 'selects objects using regular expressions' do
         selected = mapper.select { |article| article.title =~ /Pub/ }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include published_id
-        ids.should_not include draft_id
+        expect(ids).to include published_id
+        expect(ids).not_to include draft_id
       end
 
       it 'selects objects using inclusion' do
         selected = mapper.select { |article| article.title.in %w( Published ) }
         ids = selected.map { |article| mapper.id_for article }
-        ids.should include published_id
-        ids.should_not include draft_id
+        expect(ids).to include published_id
+        expect(ids).not_to include draft_id
       end
     end
 
@@ -134,9 +134,9 @@ describe "retrieval" do
       selected = mapper.select { |article| article.title }
       ids = selected.map { |article| mapper.id_for(article) }
 
-      ids.should     include truthy_id
-      ids.should_not include false_id
-      ids.should_not include nil_id
+      expect(ids).to     include truthy_id
+      expect(ids).not_to include false_id
+      expect(ids).not_to include nil_id
     end
   end
 
@@ -152,32 +152,32 @@ describe "retrieval" do
 
     it 'counts the results' do
       query = mapper.select { |article| article.title == title }
-      query.count.should == 2
+      expect(query.count).to be == 2
     end
 
     it 'checks whether any results match' do
-      mapper.any? { |article| article.title == title }.should be_true
-      mapper.any? { |article| article.title == SecureRandom.hex }.should be_false
+      expect(mapper.any? { |article| article.title == title }).to be_truthy
+      expect(mapper.any? { |article| article.title == SecureRandom.hex }).to be_falsey
     end
 
     it 'checks whether all results match' do
       mapper.delete_all
       2.times { |i| mapper.insert Article.new(title, nil, nil, nil, i) }
-      mapper.all? { |article| article.title == title }.should be_true
-      mapper.all? { |article| article.views == 0 }.should be_false
+      expect(mapper.all? { |article| article.title == title }).to be_truthy
+      expect(mapper.all? { |article| article.views == 0 }).to be_falsey
     end
 
     it 'checks whether only one result matches' do
       unique_title = SecureRandom.hex
       mapper.insert Article.new(unique_title)
-      mapper.one? { |article| article.title == unique_title }.should be_true
-      mapper.one? { |article| article.title == title }.should be_false
-      mapper.one? { |article| article.title == 'Title' }.should be_false
+      expect(mapper.one? { |article| article.title == unique_title }).to be_truthy
+      expect(mapper.one? { |article| article.title == title }).to be_falsey
+      expect(mapper.one? { |article| article.title == 'Title' }).to be_falsey
     end
 
     it 'checks whether no results match' do
-      mapper.none? { |article| article.title == SecureRandom.hex }.should be_true
-      mapper.none? { |article| article.title == title }.should be_false
+      expect(mapper.none? { |article| article.title == SecureRandom.hex }).to be_truthy
+      expect(mapper.none? { |article| article.title == title }).to be_falsey
     end
   end
 
@@ -191,7 +191,7 @@ describe "retrieval" do
       mapper.insert article
       retrieved_article = mapper.find(mapper.id_for article)
       mapper.load_association! retrieved_article, :author
-      retrieved_article.author.should be_a CRM::Person
+      expect(retrieved_article.author).to be_a CRM::Person
     end
   end
 
@@ -201,8 +201,8 @@ describe "retrieval" do
     articles.each { |article| mapper.insert article }
 
     ret = mapper.select { |article| article.title == title }.drop(2).sort(:id).to_a
-    ret.should have(1).items
-    ret.first.should == articles.last
+    expect(ret.size).to eq 1
+    expect(ret.first).to be == articles.last
   end
 
   describe 'selecting random objects' do
@@ -211,7 +211,7 @@ describe "retrieval" do
       articles = 3.times.map { Article.new(SecureRandom.hex) }
       articles.each { |article| mapper.insert article }
 
-      articles.should include mapper.sample
+      expect(articles).to include mapper.sample
     end
   end
 
@@ -220,8 +220,8 @@ describe "retrieval" do
     id = mapper.insert Article.new(fake_title)
 
     retrieved = mapper.find(id)
-    retrieved.title.should be_a String
-    retrieved.title.should == fake_title
+    expect(retrieved.title).to be_a String
+    expect(retrieved.title).to be == fake_title
   end
 
   describe 'Enumerable methods within queries' do
@@ -239,14 +239,14 @@ describe "retrieval" do
 
     it 'checks for the existence of attributes in an array' do
       results = mapper.select { |article| article.comments.any? }.to_a
-      results.should include article_with_comments
-      results.should_not include article_without_comments
+      expect(results).to include article_with_comments
+      expect(results).not_to include article_without_comments
     end
 
     it 'checks that an array has no elements' do
       results = mapper.select { |article| article.comments.none? }.to_a
-      results.should include article_without_comments
-      results.should_not include article_with_comments
+      expect(results).to include article_without_comments
+      expect(results).not_to include article_with_comments
     end
   end
 
@@ -254,13 +254,13 @@ describe "retrieval" do
     let(:id) { mapper.insert Article.new }
 
     it 'returns the same object when requested with the same id' do
-      mapper.find(id).should be mapper.find(id)
+      expect(mapper.find(id)).to be mapper.find(id)
     end
 
     it 'returns the same object when requested with a block' do
       first = mapper.find { |article| article.id == id }
       second = mapper.find { |article| article.id == id }
-      first.should be second
+      expect(first).to be second
     end
   end
 end