active_node 2.2.7 → 2.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b61a35ae17f4598504c8840a398430f85c0a6a3
-  data.tar.gz: 4ee34af5defc7d4e94f201ffac233ff0ab30344b
+  metadata.gz: 45501f3e062853d5fe6ccc8c86f421db66c5cff9
+  data.tar.gz: 03cd4becab14827bbef0bac124fd0574d0f34b24
 SHA512:
-  metadata.gz: 1f100b6302c72bc460b5f8149adaaf5bf179bb3dd6b2a84ad5db8bacb12db160ae4ad366243c19bb20a1bee3f90b20b0b11515f9fbd5d97f8c117bc52d5710fd
-  data.tar.gz: 7547f7c6a17f49dc5ad264843b16007cd17a1dc28b8f785c9fdb1fb519770eee51ff73a7a4e0b15e82b1ba889a6f4efd3facb3a60bc3d159ba483fae97409c2b
+  metadata.gz: 1bc1bda0941bf238967605fe40083c6ad2b6315d5371b5e28667fbaef5abf01e37dde54c3cacaffbb51aa971316cf7f3c52e4e3a6fe706896b3282deea7622ef
+  data.tar.gz: e39299ad270597c5c36d120056322b3ba8beb8c141210c675cbbd85d127fb525f670057a7fe3f7758d55264f8c4e2bd9fe366d93bc48b7ea218ff34335f234c2

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/active_node.gemspec

@@ -20,10 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "active_attr"
   s.add_dependency "neography"
-  s.add_dependency "activesupport"
-  s.add_dependency "activemodel"
-  s.add_development_dependency "rspec", "<= 2.14.1"
-  s.add_development_dependency "net-http-spy", "0.2.1"
+  s.add_development_dependency "rspec"
   s.add_development_dependency "rake", ">= 0.8.7"
   s.add_development_dependency "coveralls"
   s.add_development_dependency "codeclimate-test-reporter"

data/lib/active_node/base.rb

@@ -6,6 +6,7 @@ module ActiveNode
     include ActiveAttr::BasicModel
     include ActiveAttr::Attributes
     include ActiveAttr::MassAssignment
+    include ActiveAttr::AttributeDefaults
     include ActiveAttr::TypecastedAttributes
     include Typecasting
     include Dirty

data/lib/active_node/version.rb

@@ -1,3 +1,3 @@
 module ActiveNode
-  VERSION = "2.2.7"
+  VERSION = "2.2.8"
 end

data/spec/functional/associations_spec.rb

@@ -1,11 +1,9 @@
-require 'spec_helper'
-
 describe ActiveNode::Associations do
   describe "#save" do
     it "should have empty association" do
       client = Client.new(name: 'a')
       client.save
-      client.users.should be_empty
+      expect(client.users).to be_empty
     end
 
     it "should not have empty association" do
@@ -13,21 +11,21 @@ describe ActiveNode::Associations do
       user.save
       client = Client.new(name: 'a', users: [user])
       client.save
-      client.users.should == [user]
+      expect(client.users).to eq([user])
     end
 
     it "can set association by id" do
       user = NeoUser.create!(name: 'Heinrich')
       client = Client.create!(name: 'a', user_ids: [user.id])
-      client.users.to_a.should == [user]
-      client.user_ids.should == [user.id]
-      client.users.first.clients.first.should == client
+      expect(client.users.to_a).to eq([user])
+      expect(client.user_ids).to eq([user.id])
+      expect(client.users.first.clients.first).to eq(client)
       client.user_ids = []
       client.save
-      Client.find(client.id).users.should == []
+      expect(Client.find(client.id).users).to eq([])
       client.user_ids = [user.id]
       client.save
-      Client.find(client.id).users.should == [user]
+      expect(Client.find(client.id).users).to eq([user])
     end
 
     it "can remove associated objects" do
@@ -37,18 +35,18 @@ describe ActiveNode::Associations do
       client.save
       client.user_ids = []
       client.save
-      client.users.should be_empty
-      client.user_ids.should be_empty
+      expect(client.users).to be_empty
+      expect(client.user_ids).to be_empty
     end
 
     it "returns nil on a has_one association for a brand spanking new model object" do
       person = Person.new
-      person.father.should be_nil
+      expect(person.father).to be_nil
     end
 
     it "returns nil on a has_one association where nothing is associated" do
       person = Person.create!
-      person.father.should be_nil
+      expect(person.father).to be_nil
     end
 
     it "can remove some of the associated objects" do
@@ -56,10 +54,10 @@ describe ActiveNode::Associations do
       child2 = Person.create!
       person = Person.create! child_ids: [child1.id, child2.id]
       person = Person.find(person.id)
-      person.children.count.should == 2
+      expect(person.children.count).to eq(2)
       person.child_ids = [child2.id]
       person.save
-      Person.find(person.id).children.should == [child2]
+      expect(Person.find(person.id).children).to eq([child2])
     end
 
     it "can remove and add some of the associated objects" do
@@ -67,11 +65,11 @@ describe ActiveNode::Associations do
       child2 = Person.create!
       person = Person.create! child_ids: [child1.id, child2.id]
       person = Person.find(person.id)
-      person.children.count.should == 2
+      expect(person.children.count).to eq(2)
       child3 = Person.create!
       person.child_ids = [child2.id, child3.id]
       person.save
-      Person.find(person.id).children.should == [child2, child3]
+      expect(Person.find(person.id).children).to eq([child2, child3])
     end
 
     it 'can handle self referencing' do
@@ -80,12 +78,12 @@ describe ActiveNode::Associations do
       person.people = [person]
       person.save
       person.people.first == person
-      Person.count.should == 1
+      expect(Person.count).to eq(1)
     end
 
     it 'can handle reference to the same class' do
       id = Person.create!(children: [Person.create!, Person.create!]).id
-      Person.find(id).children.size.should == 2
+      expect(Person.find(id).children.size).to eq(2)
     end
 
     it 'can set has_one relation' do
@@ -93,7 +91,7 @@ describe ActiveNode::Associations do
       child = Person.create!
       child.father = father
       child.save
-      father.children.should == [child]
+      expect(father.children).to eq([child])
     end
 
     it 'can set has_one relation by id' do
@@ -101,19 +99,19 @@ describe ActiveNode::Associations do
       child = Person.create!
       child.father_id = father.id
       child.save
-      father.children.should == [child]
+      expect(father.children).to eq([child])
     end
 
     it 'can set has_one relationship by id at creation time' do
       father = Person.create!
       child = Person.create! father_id: father.id
-      father.children.should == [child]
+      expect(father.children).to eq([child])
     end
 
     it 'does not set has_one relationship by id if id is blank' do
       father = Person.create!
       child = Person.create! father_id: nil
-      father.children.should be_empty
+      expect(father.children).to be_empty
     end
 
     it 'can remove has_one relationship' do
@@ -121,7 +119,7 @@ describe ActiveNode::Associations do
       child = Person.create! father: father
       child.father = nil
       child.save
-      Person.find(child.id).father.should be_nil
+      expect(Person.find(child.id).father).to be_nil
     end
 
     it 'can read has_one relation by id' do
@@ -129,19 +127,19 @@ describe ActiveNode::Associations do
       child = Person.create!
       child.father = father
       child.save
-      child.father_id.should == father.id
+      expect(child.father_id).to eq(father.id)
     end
 
     it "can access new association without being saved" do
       father = Person.create!
       child = Person.new
       child.father = father
-      child.father.should == father
+      expect(child.father).to eq(father)
     end
 
     it 'can handle has_one reverse relationship' do
       father = Person.create!(children: [Person.create!])
-      father.children.first.father.should == father
+      expect(father.children.first.father).to eq(father)
     end
 
     it 'returns relationships to related nodes' do
@@ -150,7 +148,7 @@ describe ActiveNode::Associations do
       person = Person.create! child_ids: [child1.id, child2.id]
       person.save
       person = Person.find(person.id)
-      person.child_rels.map(&:other).should == person.children
+      expect(person.child_rels.map(&:other)).to eq(person.children)
     end
 
     it 'relationship should include property' do
@@ -158,7 +156,7 @@ describe ActiveNode::Associations do
       client.address_rel=ActiveNode::Relationship.new(Address.create!, address_type: 'home')
       client.save
       client = Client.find(client.id)
-      client.address_rel[:address_type].should == 'home'
+      expect(client.address_rel[:address_type]).to eq('home')
     end
 
     it 'should save updated property on relationship' do
@@ -170,13 +168,13 @@ describe ActiveNode::Associations do
       client.save
       client=Client.find(client.id)
       ar=client.address_rel
-      ar[:address_type].should == 'office'
+      expect(ar[:address_type]).to eq('office')
     end
 
     it 'should retrieve multiple relationships at once' do
       address = Address.create!
       person = Person.create! children: [Person.create!(address: address)]
-      Person.find(person.id).children(:address).first.address.should == address
+      expect(Person.find(person.id).children(:address).first.address).to eq(address)
     end
 
     it 'should handle simultaneous updates to father and children' do
@@ -186,7 +184,7 @@ describe ActiveNode::Associations do
       father = Person.includes(:children).find(father.id)
       father.children.first.update_attributes(father: nil)
       father.update_attributes(name: "John")
-      Person.find(father.id).children.should be_empty?
+      expect(Person.find(father.id).children).to be_empty?
     end
   end
 end

data/spec/functional/base_spec.rb

@@ -1,18 +1,16 @@
-require 'spec_helper'
-
 describe ActiveNode::Base do
   describe ".subclass" do
     it "should be ActiveNode::Base" do
-      ActiveNode::Base.subclass('Abc').should <= ActiveNode::Base
+      expect(ActiveNode::Base.subclass('Abc')).to be <= ActiveNode::Base
     end
 
     it "should have the right label" do
-      ActiveNode::Base.subclass('Abc').label.should == 'Abc'
+      expect(ActiveNode::Base.subclass('Abc').label).to eq('Abc')
     end
 
     it "should find object via subclass" do
       p = Person.create! name: 'Heinrich'
-      ActiveNode::Base.subclass('Person').find(p.id)[:name].should == p.name
+      expect(ActiveNode::Base.subclass('Person').find(p.id)[:name]).to eq(p.name)
     end
   end
 

data/spec/functional/graph/query_methods_spec.rb

@@ -1,13 +1,11 @@
-require 'spec_helper'
-
 describe ActiveNode::QueryMethods do
   describe "#order" do
     it "should order" do
       p1=Person.create!(name: 'abc')
       p2=Person.create!(name: 'def')
-      Person.order(:name).should == [p1, p2]
-      Person.order(name: :desc).should == [p2, p1]
-      Person.order('name asc').reverse_order.should == [p2, p1]
+      expect(Person.order(:name)).to eq([p1, p2])
+      expect(Person.order(name: :desc)).to eq([p2, p1])
+      expect(Person.order('name asc').reverse_order).to eq([p2, p1])
     end
   end
 
@@ -15,7 +13,7 @@ describe ActiveNode::QueryMethods do
     it "should limt" do
       p1=Person.create!(name: 'abc')
       p2=Person.create!(name: 'def')
-      Person.limit(1).should == [p1]
+      expect(Person.limit(1)).to eq([p1])
     end
   end
 end

data/spec/functional/graph_spec.rb

@@ -1,62 +1,60 @@
-require 'spec_helper'
-
 describe ActiveNode::Graph do
   describe "#path" do
     it "should parse includes" do
-      ActiveNode::Graph.new(Person, :father).send(:query).should == "optional match (n0)<-[r1:child]-(n1:`Person`)"
-      ActiveNode::Graph.new(Person, :father, :children).send(:query).should == "optional match (n0)<-[r1:child]-(n1:`Person`) optional match (n0)-[r2:child]->(n2:`Person`)"
-      ActiveNode::Graph.new(Person, children: 2).send(:query).should == "optional match (n0)-[r1:child*1..2]->(n1:`Person`)"
-      ActiveNode::Graph.new(Person, {children: :address}, :address).send(:query).should == "optional match (n0)-[r1:child]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n0)-[r3:address]->(n3:`Address`)"
-      ActiveNode::Graph.new(Person, children: [:address, :father]).send(:query).should == "optional match (n0)-[r1:child]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)"
-      ActiveNode::Graph.new(Person, {children: 2} => [:address, :father]).send(:query).should == "optional match (n0)-[r1:child*1..2]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)"
-      ActiveNode::Graph.new(Person, {children: '*'} => [:address, :father]).send(:query).should == "optional match (n0)-[r1:child*]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)"
+      expect(ActiveNode::Graph.new(Person, :father).send(:query)).to eq("optional match (n0)<-[r1:child]-(n1:`Person`)")
+      expect(ActiveNode::Graph.new(Person, :father, :children).send(:query)).to eq("optional match (n0)<-[r1:child]-(n1:`Person`) optional match (n0)-[r2:child]->(n2:`Person`)")
+      expect(ActiveNode::Graph.new(Person, children: 2).send(:query)).to eq("optional match (n0)-[r1:child*1..2]->(n1:`Person`)")
+      expect(ActiveNode::Graph.new(Person, {children: :address}, :address).send(:query)).to eq("optional match (n0)-[r1:child]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n0)-[r3:address]->(n3:`Address`)")
+      expect(ActiveNode::Graph.new(Person, children: [:address, :father]).send(:query)).to eq("optional match (n0)-[r1:child]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)")
+      expect(ActiveNode::Graph.new(Person, {children: 2} => [:address, :father]).send(:query)).to eq("optional match (n0)-[r1:child*1..2]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)")
+      expect(ActiveNode::Graph.new(Person, {children: '*'} => [:address, :father]).send(:query)).to eq("optional match (n0)-[r1:child*]->(n1:`Person`) optional match (n1)-[r2:address]->(n2:`Address`) optional match (n1)<-[r3:child]-(n3:`Person`)")
     end
 
     it "should build graph" do
       person = Person.create! children: [c1=Person.create!, c2=Person.create!(address: a=Address.create!)]
       g_person = person.includes!({children: '*'} => [:address, :father])
       g_person = ActiveNode::Graph.new(Person, {children: '*'} => [:address, :father]).build(person).first
-      g_person.should == person
-      g_person.object_id.should == person.object_id
-      ActiveNode::Neo.should_not_receive(:db)
-      g_person.children.last.address.should == a
+      expect(g_person).to eq(person)
+      expect(g_person.object_id).to eq(person.object_id)
+      expect(ActiveNode::Neo).not_to receive(:db)
+      expect(g_person.children.last.address).to eq(a)
       g_person.children.first.father = person
-      g_person.children.should == [c1, c2]
+      expect(g_person.children).to eq([c1, c2])
     end
 
     it "should not query db twice" do
       pending
       person = Person.create!
       person.includes! :children
-      ActiveNode::Neo.should_not_receive(:db)
+      expect(ActiveNode::Neo).not_to receive(:db)
       person.children
     end
   end
 
   describe '#empty?' do
     it 'should return true' do
-      Person.all.should be_empty
+      expect(Person.all).to be_empty
     end
   end
 
   describe '#detect' do
     it 'should return nil' do
-      Person.all.detect { |p| true }.should be_nil
+      expect(Person.all.detect { |p| true }).to be_nil
     end
   end
 
   describe '#includes' do
     it 'should not throw an error' do
       p = Person.create! father: Person.create!
-      Person.where(id: p.id).includes(:father).first.should == p
+      expect(Person.where(id: p.id).includes(:father).first).to eq(p)
     end
 
     it "should return correct associated objects" do
       child1 = Person.create! children: [Person.create!, Person.create!]
       person = Person.create! children: [child1]
-      Person.includes(children: :children).find(person.id).children.should == [child1]
-      Person.includes(children: 2).find(person.id).children.should == [child1]
-      Person.includes(children: '*').find(person.id).children.should == [child1]
+      expect(Person.includes(children: :children).find(person.id).children).to eq([child1])
+      expect(Person.includes(children: 2).find(person.id).children).to eq([child1])
+      expect(Person.includes(children: '*').find(person.id).children).to eq([child1])
     end
   end
 end

data/spec/functional/persistence_spec.rb

@@ -1,22 +1,20 @@
-require 'spec_helper'
-
 describe ActiveNode::Persistence do
   describe "#save" do
     it "should save an object" do
       a=Address.create!
-      Address.find(a.id).should == a
+      expect(Address.find(a.id)).to eq(a)
     end
 
     it "should not set id property" do
       a = Address.create!
-      ActiveNode::Neo.db.get_node_properties(a.id).should be_nil
+      expect(ActiveNode::Neo.db.get_node_properties(a.id)['id']).to be_nil
       a.save
-      ActiveNode::Neo.db.get_node_properties(a.id).should be_nil
+      expect(ActiveNode::Neo.db.get_node_properties(a.id)['id']).to be_nil
     end
 
     it "should save unconventionally named object" do
-      NeoUser.new(name: 'Heinrich').save.should be_true
-      NeoUser.all.map(&:name).should == ['Heinrich']
+      expect(NeoUser.new(name: 'Heinrich').save).to be_truthy
+      expect(NeoUser.all.map(&:name)).to eq(['Heinrich'])
     end
 
     it "should save object with non attribute properties with a name of a relationship" do
@@ -25,44 +23,44 @@ describe ActiveNode::Persistence do
       person[:children] = "Bob"
       person.save
       person = Person.find person.id
-      person[:children].should == "Bob"
-      person.children.should == [child]
+      expect(person[:children]).to eq("Bob")
+      expect(person.children).to eq([child])
     end
 
     it 'should destroy node' do
       user = NeoUser.create!(name: 'abc')
-      NeoUser.count.should == 1
-      user.destroy.should be_true
-      NeoUser.count.should == 0
+      expect(NeoUser.count).to eq(1)
+      expect(user.destroy).to be_truthy
+      expect(NeoUser.count).to eq(0)
     end
 
     it 'should not destroy node with relationships' do
       person = Person.create! children: [Person.create!, Person.create!]
-      person.destroy.should be_false
-      Person.count.should == 3
+      expect(person.destroy).to be_falsey
+      expect(Person.count).to eq(3)
     end
 
     it 'should destroy! node with relationships' do
       person = Person.create! children: [Person.create!, Person.create!]
-      person.destroy!.should be_true
-      Person.count.should == 2
+      expect(person.destroy!).to be_truthy
+      expect(Person.count).to eq(2)
     end
 
     it 'should record timestamp' do
       now = Time.now
       person = Person.create!
-      person.created_at.should_not be_nil
+      expect(person.created_at).not_to be_nil
       person = Person.find(person.id)
-      person.created_at.should_not be_nil
-      person.updated_at.should_not be_nil
+      expect(person.created_at).not_to be_nil
+      expect(person.updated_at).not_to be_nil
       allow(Time).to receive(:now) { now + 1.second }
       person.name = 'abc'
       person.save
-      (person.created_at < person.updated_at).should be_true
+      expect(person.created_at < person.updated_at).to be_truthy
     end
 
     it 'should not record timestamp if not specified' do
-      Client.create!(name: 'abc').respond_to?(:created_at).should be_false
+      expect(Client.create!(name: 'abc').respond_to?(:created_at)).to be_falsey
     end
   end
 
@@ -82,47 +80,47 @@ describe ActiveNode::Persistence do
 
   describe "#create!" do
     it "should persist attributes" do
-      Person.create!(name: 'abc').name.should == 'abc'
+      expect(Person.create!(name: 'abc').name).to eq('abc')
     end
 
     it "should persist array properties" do
       person = Person.create!(multi: [1, 2, 3])
-      Person.find(person.id).multi.should == [1, 2, 3]
+      expect(Person.find(person.id).multi).to eq([1, 2, 3])
     end
   end
 
   describe "#find" do
     it 'should find an object by id' do
       person = Person.create!
-      Person.find(person.id).should == person
+      expect(Person.find(person.id)).to eq(person)
     end
 
     it 'should find objects passing multiple ids' do
       person1 = Person.create!
       person2 = Person.create!
-      Person.find([person1.id, person2.id]).to_a.should == [person1, person2]
+      expect(Person.find([person1.id, person2.id]).to_a).to eq([person1, person2])
     end
 
     it 'should find an object with id of an unknown model' do
-      ActiveNode::Base.find(Person.create!.id).class.should == Person
+      expect(ActiveNode::Base.find(Person.create!.id).class).to eq(Person)
     end
   end
 
   describe "#attributes" do
     it "should include id" do
-      Person.create!(name: 'abc').attributes['id'].should_not be_nil
+      expect(Person.create!(name: 'abc').attributes['id']).not_to be_nil
     end
   end
 
   describe "#to_param" do
     it "should return a string version of the id" do
       person = Person.create!
-      person.to_param.should == person.id.to_s
+      expect(person.to_param).to eq(person.id.to_s)
     end
 
     it "should return nil if the id is nil" do
       person = Person.new
-      person.to_param.should be_nil
+      expect(person.to_param).to be_nil
     end
   end
 
@@ -149,7 +147,7 @@ describe ActiveNode::Persistence do
       a = Address.create!
       p=Person.create!(name: 'abc', address: a)
       c=Client.create!(name: 'client', address: a)
-      a.incoming(:address).should include(p, c)
+      expect(a.incoming(:address)).to include(p, c)
     end
   end
 
@@ -157,13 +155,23 @@ describe ActiveNode::Persistence do
     it "should update atribute without validation" do
       client = Client.create!(name: 'abc')
       client.update_attribute(:name, nil)
-      Client.find(client.id).name.should be_nil
+      expect(Client.find(client.id).name).to be_nil
     end
   end
 
   describe "#wrap" do
     it "should wrap nil as nil" do
-      Client.wrap(nil).should be_nil
+      expect(Client.wrap(nil)).to be_nil
+    end
+  end
+
+  describe "default" do
+    it "should default new object" do
+      expect(Address.new.city).to eq "New York"
+    end
+
+    it "should default created object" do
+      expect(Address.create!.city).to eq "New York"
     end
   end
 end

data/spec/functional/validations_spec.rb

@@ -1,32 +1,30 @@
-require 'spec_helper'
-
 describe ActiveNode::Validations do
   describe "#save" do
     it "should not save invalid object" do
-      Client.new.save.should be_false
+      expect(Client.new.save).to be_falsey
     end
 
     it "should save valid object" do
-      Client.new(name: 'abc7').save.should be_true
-      Client.all.first.name.should == 'abc7'
+      expect(Client.new(name: 'abc7').save).to be_truthy
+      expect(Client.all.first.name).to eq('abc7')
     end
 
     describe "with uniqueness constraint" do
       it "should validate uniqueness" do
         Person.create! name: 'abc'
-        Person.new(name: 'abc').should_not be_valid
+        expect(Person.new(name: 'abc')).not_to be_valid
       end
 
       it "should still be valid after save" do
         person = Person.create! name: "abc"
-        person.should be_valid
+        expect(person).to be_valid
       end
     end
 
     it "should validate presence on has_one" do
-      House.new.should_not be_valid
+      expect(House.new).not_to be_valid
       house = House.create! address_id: Address.create!.id
-      House.find(house.id).should be_valid
+      expect(House.find(house.id)).to be_valid
     end
   end
 end

data/spec/models/address.rb

@@ -1,2 +1,3 @@
 class Address < ActiveNode::Base
+  attribute :city, type: String, default: "New York"
 end

data/spec/spec_helper.rb

@@ -42,12 +42,12 @@ end
 
 def error_response(attributes)
   request_uri = double()
-  request_uri.stub(:request_uri).and_return("")
+  allow(request_uri).to receive(:request_uri).and_return("")
 
   http_header = double()
-  http_header.stub(:request_uri).and_return(request_uri)
+  allow(http_header).to receive(:request_uri).and_return(request_uri)
 
-  stub(
+  double(
     http_header: http_header,
     code: attributes[:code],
     body: {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_node
 version: !ruby/object:Gem::Version
-  version: 2.2.7
+  version: 2.2.8
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-24 00:00:00.000000000 Z
+date: 2014-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -39,61 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: activemodel
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   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: 2.14.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: 2.14.1
-- !ruby/object:Gem::Dependency
-  name: net-http-spy
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +102,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".travis.yml"
 - Gemfile
 - LICENSE