perpetuity 1.0.0 → 1.0.1

data/spec/perpetuity/rails_model_spec.rb

@@ -12,73 +12,84 @@ module Perpetuity
     let(:wrapper) { object.to_model }
 
     it 'determines whether it is persisted based on @id ivar' do
-      object.should_not be_persisted
+      expect(object).not_to be_persisted
       object.id = 'lol'
-      object.should be_persisted
+      expect(object).to be_persisted
     end
 
     it 'returns the id as to_param' do
-      object.to_param.should be == nil
+      expect(object.to_param).to be == nil
       object.id = 'foo'
-      object.to_param.should be == 'foo'
+      expect(object.to_param).to be == 'foo'
     end
 
     it 'returns the keys on the object' do
-      object.to_key.should be == nil
+      expect(object.to_key).to be == nil
       object.id = 'bar'
-      object.to_key.should be == ['bar']
+      expect(object.to_key).to be == ['bar']
     end
 
     it 'returns the model name' do
-      klass.model_name.should be == klass
+      expect(klass.model_name).to be == klass
+      expect(klass.new.model_name).to be == klass
+    end
+
+    it 'returns self as the model' do
+      model = klass.new
+      expect(model.to_model).to be model
+    end
+
+    it 'returns its name in lowercase as the i18n key' do
+      stub_const 'Foo::BarBaz', klass
+      expect(klass.i18n_key).to be == 'foo.bar_baz'
     end
 
     describe 'param_key' do
       it 'converts :: to _' do
         stub_const 'Foo::Bar', klass
-        Foo::Bar.param_key.should be == 'foo_bar'
+        expect(Foo::Bar.param_key).to be == 'foo_bar'
       end
 
       it 'converts title-case to snake-case' do
         stub_const 'UserRegistration', klass
-        UserRegistration.param_key.should be == 'user_registration'
+        expect(UserRegistration.param_key).to be == 'user_registration'
       end
     end
 
     it 'returns the route_key' do
       stub_const 'Foo::Bar', klass
-      Foo::Bar.route_key.should be == 'foo_bars'
+      expect(Foo::Bar.route_key).to be == 'foo_bars'
     end
 
     it 'returns the singular_route_key' do
       stub_const 'Foo::Bar', klass
-      Foo::Bar.singular_route_key.should be == 'foo_bar'
+      expect(Foo::Bar.singular_route_key).to be == 'foo_bar'
     end
 
     it 'returns the partial path' do
       stub_const 'Article', klass
-      Article.to_partial_path.should be == 'articles/_article'
+      expect(Article.to_partial_path).to be == 'articles/_article'
     end
 
     describe 'human' do
       it 'returns the class name for a single-word class name' do
         stub_const 'Article', klass
-        Article.human.should == 'Article'
+        expect(Article.human).to be == 'Article'
       end
 
       it 'converts namespaced to capitalized words' do
         stub_const 'Foo::Bar', klass
-        Foo::Bar.human.should == 'Foo Bar'
+        expect(Foo::Bar.human).to be == 'Foo Bar'
       end
 
       it 'separates title-cased words' do
         stub_const 'FooBarBaz', klass
-        FooBarBaz.human.should == 'Foo Bar Baz'
+        expect(FooBarBaz.human).to be == 'Foo Bar Baz'
       end
 
       it 'separates snake-cased, capitalized words' do
         stub_const 'FOO_BAR_BAZ', klass
-        FOO_BAR_BAZ.human.should == 'Foo Bar Baz'
+        expect(FOO_BAR_BAZ.human).to be == 'Foo Bar Baz'
       end
     end
   end

data/spec/perpetuity/reference_spec.rb

@@ -8,8 +8,13 @@ module Perpetuity
 
     before { object.instance_variable_set :@id, 1 }
 
-    its(:klass) { should be Object }
-    its(:id)    { should be == 1 }
+    it "stores the object's class in the `klass` attribute" do
+      expect(reference.klass).to be Object
+    end
+
+    it "stores the object's id" do
+      expect(reference.id).to be 1
+    end
 
     describe 'comparability' do
       describe 'equality' do

data/spec/perpetuity/retrieval_spec.rb

@@ -12,62 +12,62 @@ module Perpetuity
 
     it "sorts the results" do
       sorted = retrieval.sort(:name)
-      sorted.sort_attribute.should == :name
+      expect(sorted.sort_attribute).to be == :name
     end
 
     it "reverses the sort order of the results" do
       sorted = retrieval.sort(:name).reverse
-      sorted.sort_direction.should == :descending
+      expect(sorted.sort_direction).to be == :descending
     end
     
     it "limits the result set" do
-      retrieval.limit(1).result_limit.should == 1
+      expect(retrieval.limit(1).result_limit).to be == 1
     end
 
     it 'indicates whether it includes a specific item' do
-      subject.stub(to_a: [1])
-      subject.should include 1
+      allow(subject).to receive(:to_a) { [1] }
+      expect(subject).to include 1
     end
 
     it 'can be empty' do
-      retrieval.stub(to_a: [])
-      retrieval.should be_empty
+      allow(retrieval).to receive(:to_a) { [] }
+      expect(retrieval).to be_empty
     end
 
     describe 'pagination' do
       let(:paginated) { retrieval.page(2) }
       it 'paginates data' do
-        paginated.result_offset.should == 20
+        expect(paginated.result_offset).to be == 20
       end
 
       it 'defaults to 20 items per page' do
-        paginated.result_limit.should == 20
+        expect(paginated.result_limit).to be == 20
       end
 
       it 'sets the number of items per page' do
-        paginated.per_page(50).result_limit.should == 50
+        expect(paginated.per_page(50).result_limit).to be == 50
       end
     end
 
     it 'retrieves data from the data source' do
       return_data = { id: 0, a: 1, b: 2 }
       return_object = Object.new
-      return_object.stub(id: return_data[:id])
+      allow(return_object).to receive(:id) { return_data[:id] }
       options = { attribute: nil, direction: nil, limit: nil, skip: nil }
 
-      data_source.should_receive(:retrieve).with('Object', query, options).
+      expect(data_source).to receive(:retrieve).with('Object', query, options).
                   and_return([return_data])
-      data_source.should_receive(:unserialize).with([return_data], mapper) { [return_object] }
-      mapper.stub(:id_for)
+      expect(data_source).to receive(:unserialize).with([return_data], mapper) { [return_object] }
+      allow(mapper).to receive(:id_for)
       results = retrieval.to_a
 
-      results.map(&:id).should == [0]
+      expect(results.map(&:id)).to be == [0]
     end
 
     it 'clears results cache' do
       retrieval.result_cache = [1,2,3]
       retrieval.clear_cache
-      retrieval.result_cache.should be_nil
+      expect(retrieval.result_cache).to be_nil
     end
 
     describe 'identity map' do
@@ -75,18 +75,18 @@ module Perpetuity
       let(:retrieval) { Retrieval.new(mapper, query, identity_map: id_map) }
 
       it 'maintains an identity_map' do
-        retrieval.identity_map.should be id_map
+        expect(retrieval.identity_map).to be id_map
       end
 
       it 'returns objects from the identity map with queries' do
         result = Object.new
         result.instance_variable_set :@id, '1'
         id_map << result
-        mapper.stub(id_for: '1')
-        data_source.stub(:retrieve)
-        data_source.stub(unserialize: [result.dup])
+        allow(mapper).to receive(:id_for) { '1' }
+        allow(data_source).to receive(:retrieve)
+        allow(data_source).to receive(:unserialize) { [result.dup] }
 
-        retrieval.to_a.should include result
+        expect(retrieval.to_a).to include result
       end
     end
   end

data/spec/perpetuity_spec.rb

@@ -5,7 +5,7 @@ describe Perpetuity do
   describe 'mapper generation' do
     it 'generates mappers' do
       Perpetuity.generate_mapper_for Object
-      Perpetuity[Object].should be_a Perpetuity::Mapper
+      expect(Perpetuity[Object]).to be_a Perpetuity::Mapper
     end
 
     it 'provides a DSL within the generated mapper' do
@@ -17,8 +17,8 @@ describe Perpetuity do
       mapper = Perpetuity[Object]
       object = Object.new
       mapper.insert object
-      mapper.id_for(object).should be == object.object_id + 1
-      mapper.attributes.should include :object_id
+      expect(mapper.id_for(object)).to be == object.object_id + 1
+      expect(mapper.attributes).to include :object_id
     end
   end
 
@@ -41,12 +41,12 @@ describe Perpetuity do
 
     it 'allows methods to act as scopes' do
       published_ids = mapper.published.to_a.map { |article| mapper.id_for(article) }
-      published_ids.should include published_id
-      published_ids.should_not include draft_id, not_yet_published_id
+      expect(published_ids).to include published_id
+      expect(published_ids).not_to include draft_id, not_yet_published_id
 
       unpublished_ids = mapper.unpublished.to_a.map { |article| mapper.id_for(article) }
-      unpublished_ids.should_not include published_id
-      unpublished_ids.should include draft_id, not_yet_published_id
+      expect(unpublished_ids).not_to include published_id
+      expect(unpublished_ids).to include draft_id, not_yet_published_id
     end
   end
 
@@ -57,19 +57,19 @@ describe Perpetuity do
 
     it 'registers an adapter' do
       Perpetuity.register_adapter :example => ExampleAdapter
-      Perpetuity::Configuration.adapters[:example].should == ExampleAdapter
+      expect(Perpetuity::Configuration.adapters[:example]).to be == ExampleAdapter
     end
 
     it 'can re-register an adapter' do
       Perpetuity.register_adapter :example => ExampleAdapter
       Perpetuity.register_adapter :example => ExampleAdapter
-      Perpetuity::Configuration.adapters[:example].should == ExampleAdapter
+      expect(Perpetuity::Configuration.adapters[:example]).to be == ExampleAdapter
     end
 
     it 'cannot re-register an adapter with a different class than originally registered' do
       Perpetuity.register_adapter :example => ExampleAdapter
       expect { Perpetuity.register_adapter :example => TrueClass }.to raise_exception
-      Perpetuity::Configuration.adapters[:example].should == ExampleAdapter
+      expect(Perpetuity::Configuration.adapters[:example]).to be == ExampleAdapter
     end
   end
 

metadata

@@ -1,50 +1,53 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: perpetuity
-version: !ruby/object:Gem::Version 
-  version: 1.0.0
+version: !ruby/object:Gem::Version
+  version: 1.0.1
 platform: ruby
-authors: 
+authors:
 - Jamie Gaskins
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-08-16 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - &id003 
-      - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.13"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Persistence layer for Ruby objects
-email: 
+email:
 - jgaskins@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .rvmrc
-- .travis.yml
+files:
+- ".gitignore"
+- ".rvmrc"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
@@ -104,29 +107,30 @@ files:
 - spec/support/test_classes/topic.rb
 - spec/support/test_classes/user.rb
 homepage: https://github.com/jgaskins/perpetuity
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Persistence library allowing serialization of Ruby objects
-test_files: 
+test_files:
 - spec/integration/associations_spec.rb
 - spec/integration/deletion_spec.rb
 - spec/integration/enumerable_spec.rb