dm-persevere-adapter 0.71.4 → 0.72.0

data/lib/dm/resource.rb

@@ -1,102 +0,0 @@
-module DataMapper
-  module Resource
-
-    def get_new_objects
-      new_parents = parent_resources.select{|p| p.new? }
-      new_children = child_collections.collect{ |collection| collection.select{|c| c.new? }}.flatten
-      new_children_of_new_parents = new_parents.map{ |np| np.__send__(:child_collections).collect{ |n| select{ |p| p.new? }}}.flatten
-      new_parents_of_new_children = new_children.map{ |nc| nc.__send__(:parent_resources).select{|p| p.new? }}.flatten
-      [ new_parents, new_children, new_children_of_new_parents, new_parents_of_new_children, self.new? ? self : [] ].flatten.uniq
-    end
-
-    def create_hook
-      op = original_attributes.dup
-      _create
-      @_original_attributes = op.dup
-    end
-    
-    alias _old_update _update
-    def _update
-      if repository.adapter.is_a?(DataMapper::Adapters::PersevereAdapter)
-        # remove from the identity map
-        remove_from_identity_map
-    
-        repository.update(dirty_attributes, collection_for_self)
-    
-        # remove the cached key in case it is updated
-        remove_instance_variable(:@_key)
-    
-        add_to_identity_map
-    
-        true
-      else
-        _old_update
-      end
-    end
-
-    alias _old_save _save
-     def _save(safe)
-       objects = get_new_objects
-       objects.each do |obj|
-         obj.__send__(:save_self, safe)
-       end
-       _old_save(safe)
-     end
-
-    ##
-    # Convert a DataMapper Resource to a JSON.
-    #
-    # @param [Query] query
-    #   The DataMapper query object passed in
-    #
-    # @api semipublic
-    def to_json_hash(include_relationships=true)
-      json_rsrc = Hash.new
-      relations = self.model.relationships.keys
-      
-      if include_relationships
-        self.model.relationships.each do |nom, relation|
-          value = relation.get!(self)
-          parent = relation.parent_model
-          child = relation.child_model
-          
-          unless value.nil?
-            json_rsrc[nom] = case relation
-              # KEEP THIS CASE AT THE TOP BECAUSE IT IS_A OneToMany ARGH
-            when DataMapper::Associations::ManyToMany::Relationship then
-              [value].flatten.map{ |v| { "$ref" => "../#{v.model.storage_name}/#{v.key.first}" } }
-            when DataMapper::Associations::ManyToOne::Relationship then 
-              { "$ref" => "../#{value.model.storage_name}/#{value.key.first}" }
-            when DataMapper::Associations::OneToMany::Relationship then
-              value.map{ |v| { "$ref" => "../#{v.model.storage_name}/#{v.key.first}" } }
-            when DataMapper::Associations::OneToOne::Relationship then
-              { "$ref" => "../#{value.model.storage_name}/#{value.first.key.first}" }
-            end
-          end
-        end
-      end
-
-      attributes(:property).each do |property, value|
-        # debugger if model.name == 'Yogo::Setting' && property.name == :value
-        next if value.nil? || (value.is_a?(Array) && value.empty?) || relations.include?(property.name.to_s)
-
-        if property.type.respond_to?(:dump)
-          json_rsrc[property.field] = property.type.dump(value, nil)
-        else
-          json_rsrc[property.field] = case value
-          when DateTime then value.new_offset(0).strftime("%Y-%m-%dT%H:%M:%SZ")
-          when Date then value.to_s
-          when Time then value.strftime("%H:%M:%S")
-          when Float then value.to_f
-          when BigDecimal then value.to_f
-          when Integer then value.to_i
-          else # when String, TrueClass, FalseClass then
-            self[property.name]
-          end
-        end
-      end
-
-      json_rsrc
-    end
-  end
-end

data/spec/persevere_spec.rb

@@ -1,201 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require Pathname(__FILE__).dirname.expand_path.parent + 'lib/persevere'
-
-describe Persevere do
-  #
-  # Create an object to interact with Persevere
-  #
-  before :all do
-    @p = Persevere.new('http://localhost:8080')
-
-    @blobObj = {
-      'id' => 'Yogo',
-      'properties' => {
-        'cid' => {'type' => 'string', 'optional' => true },
-        'parent' => { 'type' => 'string', 'optional' => true},
-        'data' => { 'type' => 'string', 'optional' => true}
-      }
-    }
-    
-    @corruptObj = {
-      'id' => 'Corrupt',
-      'properties' => {
-        'id' => 1234,
-        'parent' => { 'type' => 'string'},
-        'data' => { 'type' => 'string'}
-      }
-    }
-    
-    @mockObj = {
-      'id' => 'Yogo',
-      'properties' => {
-        'cid' => {'type' => 'string', 'optional' => true },
-        'parent' => { 'type' => 'string', 'optional' => true},
-        'data' => { 'type' => 'string', 'optional' => true}
-      },
-      'prototype' => {}
-    }
-    
-    @object = {
-      'cid' => '123',
-      'parent' => 'none',
-      'data' => 'A Chunk Of Data'
-    }
-    
-  end
-  
-  
-  # Test POST to create a new class
-  
-  describe '#post' do
-     it 'should create a new object in persevere' do
-       result = @p.create('/Class/', @blobObj)
-       result.code.should == "201"
-       JSON.parse(result.body).should == @mockObj
-     end
-     
-     # it 'should not allow posting with a bad object' do
-     #   result = @p.create('/Class/', @corruptObj)
-     #   result.code.should == "500"
-     #   result.body.should == "\"Can not modify queries\""
-     # end
-     
-     it 'should not allow posting to an existing object/id/path' do
-       result = @p.create('/Class/', @blobObj)
-       result.code.should == "201"
-       JSON.parse(result.body).should == @blobObj
-       # This shouldn't be a 201, it should say something mean.
-     end
-  end
-  
-   #
-   # Test GET to retrieve the list of classes from Persvr
-   #
-   describe '#get' do
-     it 'should retrieve the previously created object from persevere' do
-       result = @p.retrieve('/Class/Yogo')
-       result.code.should == "200"
-       JSON.parse(result.body).should == @blobObj
-     end
-     
-     it 'should 404 on a non-existent object' do
-       result = @p.retrieve('/Class/GetNotThere')
-       result.code.should == "404"
-       result.message.should == "Not Found"
-     end
-   end
-  
-   #
-   # Test PUT to modify an existing class
-   #
-   describe '#put' do
-     it 'should modify the previously created object in persevere' do
-       @blobObj['properties']['tstAttribute'] = { 'type' => 'string' }
-       result = @p.update('/Class/Yogo', @blobObj)
-       result.code.should == "200"
-       JSON.parse(result.body).should == @blobObj
-     end
-     
-     it 'should fail to modify a non-existent item' do
-       result = @p.update('/Class/NonExistent', @blobObj)
-       result.code.should == "500"
-       result.body.should == "\"id does not match location\""
-       @p.delete('/Class/NonExistent') # A bug(?) in Persevere makes a broken NonExistent class.
-       # This should be a 404 and not throw a persevere server exception
-     end
-   end
-  
-   #
-   # Test DELETE to remove the previously created and modified class
-   #
-   describe '#delete' do
-     it 'should remove the previously created and modified object from persevere' do
-       result = @p.delete('/Class/Yogo')
-       result.code.should == "204"
-       @p.retrieve('/Class/Yogo').code.should == "404"
-     end
-     
-     it 'should fail to delete a non-existent item' do
-       result = @p.delete('/Class/NotThere')
-       result.code.should == "404"
-       result.message.should == "Not Found"
-       result.body.should == "\"Class/NotThere not found\""
-     end
-   end
-   
-   describe "POSTing objects" do
-     before(:all) do
-       @p.create('/Class/', @blobObj)
-     end
-     
-     it "should not allow nil fields to be posted" do
-       obj_with_nil = @object.merge({'cid' => nil})
-       result = @p.create('/Yogo', obj_with_nil)
-       result.code.should == "201"
-       JSON.parse(result.body).reject{|key,value| key == 'id' }.should == 
-          obj_with_nil.reject{|key,value| value.nil?}
-     end
-     
-     after(:all) do
-       @p.delete('/Class/Yogo')
-     end
-   end
-  
-  describe "GETting limits and offsets" do
-    before(:all) do
-      @p.create('/Class/', @blobObj)
-      (0..99).each do |i|
-        @p.create('/Yogo/', @object.merge({'cid' => "#{i}"}))
-      end
-    end
-
-    it "should only retrieve all objects" do
-      result = @p.retrieve('/Yogo/')
-      result.code.should == "200"
-      JSON.parse(result.body).length.should == 100
-    end
-    
-    it "should retrieve the first objects" do
-      result = @p.retrieve('/Yogo/1')
-      result.code.should == "200"
-      JSON.parse(result.body)['id'].should == '1'
-    end
-    
-    it "should retrieve a 10 of the objects" do
-        result = @p.retrieve('/Yogo/', {'Range' => "items=1-10"})
-        result.code.should == '206'
-        JSON.parse(result.body).length.should == 10
-    end
-    
-    it "should return the first 2 objects" do
-      result = @p.retrieve('/Yogo/', {'Range' => "items=0-1"})
-      result.code.should == '206'
-      json = JSON.parse(result.body)
-      json.length.should == 2
-      json[0]['id'].should == '1'
-      json[1]['id'].should == '2'
-    end
-    
-    it "should return 21 and up objects" do
-      result = @p.retrieve('/Yogo/', {'Range' => 'items=20-'})
-      result.code.should == '206'
-      json = JSON.parse(result.body)
-      json.length.should == 80
-      json[0]['id'].should == '21'
-      json[-1]['id'].should == '100'      
-    end
-
-    it "should return objects with id's 11 - 15" do
-      result = @p.retrieve('/Yogo/', {'Range' => 'items=10-14'})
-      result.code.should == '206'
-      json = JSON.parse(result.body)
-      json.length.should == 5
-      json[0]['id'].should == '11'
-      json[-1]['id'].should == '15'      
-    end
-    
-    after(:all) do
-      @p.delete('/Class/Yogo')
-    end
-  end
-end