dm-riak-adapter 0.0.2 → 0.0.3

data/README.md

@@ -14,19 +14,19 @@ Install the **dm-riak-adapter** gem:
 
 ## Usage
 
-Require **dm-core** and **dm-riak-adapter**. Tell DataMapper to use the Riak adapter and set a namespace for your app. This namespace will prefix each bucket like the following. `myapp:projects` `myapp:tasks`
+Require **dm-core** and **dm-riak-adapter**. Tell DataMapper to use the Riak adapter and set a namespace for your app. This namespace will prefix each bucket like `myapp:projects` `myapp:tasks`. You can also skip setting a namespace and the buckets wont have any prefix.
 
       require 'dm-core'
       require 'dm-riak-adapter'
       
       DataMapper.setup :default, :adapter => 'riak', :namespace => 'myapp'
       
-Continue Defining your models and properties as you normally would.
+Continue Defining your models and properties as you normally would. Set the serial number as type **Key** to use Riak's server-assigned UUIDs.
       
       class Project
         include DataMapper::Resource
         
-        property :id,   Serial
+        property :id,   Key
         property :name, String
         
         has n, :tasks
@@ -35,7 +35,7 @@ Continue Defining your models and properties as you normally would.
       class Task
         include DataMapper::Resource
         
-        property :id,       Serial
+        property :id,       Key
         property :summary,  String
         
         belongs_to :project

data/lib/dm-riak-adapter/adapter.rb

@@ -0,0 +1,71 @@
+module DataMapper::Adapters
+  class RiakAdapter < AbstractAdapter
+    def initialize(name, options)
+      super
+      @riak = Riak::Client.new(:prefix => options[:prefix] || 'riak')
+      @namespace = options[:namespace] ? options[:namespace] + ':' : ''
+    end
+    
+    def create(resources)
+      create_objects(resources)
+    end
+    
+    def read(query)
+      query.filter_records(objects_for(query.model)).each do |object|
+        query.fields.each do |property|
+          object[property.name.to_s] = property.typecast(object[property.name.to_s])
+        end
+      end
+    end
+    
+    def update(attributes, collection)
+      attributes = attributes_as_fields(attributes)
+      
+      objects_for(collection.query.model).each {|r| r.update(attributes)}
+      update_objects(collection)
+    end
+    
+    def delete(collection)
+      delete_objects(collection)
+    end
+    
+    def flush(model)
+      bucket(model).keys.each {|key| bucket(model)[key].delete}
+    end
+    
+    private
+    
+    def bucket(model)
+      @riak.bucket(@namespace + model.storage_name)
+    end
+    
+    def objects_for(model)
+      bucket(model).keys.map {|key| bucket(model)[key].data}
+    end
+    
+    def create_objects(resources)
+      resources.each do |resource|
+        object = bucket(resource.model).new.store
+        initialize_serial(resource, object.key)
+        object.data = resource.attributes(:field)
+        object.store
+      end
+    end
+    
+    def update_objects(resources)
+      resources.each do |resource|
+        object = bucket(resource.model)[resource.key[0]]
+        object.data = resource.attributes(:field)
+        object.store
+      end
+    end
+    
+    def delete_objects(resources)
+      resources.each do |resource|
+        bucket(resource.model)[resource.key[0]].delete
+      end
+    end
+  end
+  
+  const_added(:RiakAdapter)
+end

data/lib/dm-riak-adapter/key.rb

@@ -0,0 +1,8 @@
+module DataMapper
+  module Types
+    class Key < Type
+      primitive String
+      serial    true
+    end
+  end
+end

data/lib/dm-riak-adapter.rb

@@ -1,67 +1,6 @@
+$: << File.dirname(__FILE__)
+
 require 'riak'
 
-module DataMapper::Adapters
-  class RiakAdapter < AbstractAdapter
-    def initialize(name, options)
-      super
-      @riak = Riak::Client.new(:prefix => options[:prefix] || 'riak')
-      @namespace = options[:namespace] ? options[:namespace] + ':' : ''
-    end
-    
-    def create(resources)
-      objects = objects_for(resources.first.model)
-      
-      resources.each {|r| initialize_serial(r, objects.size.succ)}
-      create_objects(resources)
-    end
-    
-    def read(query)
-      query.filter_records(objects_for(query.model).dup)
-    end
-    
-    def update(attributes, collection)
-      attributes = attributes_as_fields(attributes)
-      
-      objects_for(collection.query.model).each {|r| r.update(attributes)}
-      update_objects(collection)
-    end
-    
-    def delete(collection)
-      delete_objects(collection)
-    end
-    
-    private
-    
-    def bucket(model)
-      @riak.bucket(@namespace + model.storage_name)
-    end
-    
-    def objects_for(model)
-      bucket(model).keys.map {|key| bucket(model)[key].data}
-    end
-    
-    def create_objects(resources)
-      resources.each do |resource|
-        object = bucket(resource.model).new("#{resource.id}")
-        object.data = resource.attributes(:field)
-        object.store
-      end
-    end
-    
-    def update_objects(resources)
-      resources.each do |resource|
-        object = bucket(resource.model)["#{resource.id}"]
-        object.data = resource.attributes(:field)
-        object.store
-      end
-    end
-    
-    def delete_objects(resources)
-      resources.each do |resource|
-        bucket(resource.model)["#{resource.id}"].delete
-      end
-    end
-  end
-  
-  const_added(:RiakAdapter)
-end
+require 'dm-riak-adapter/adapter'
+require 'dm-riak-adapter/key'

data/spec/dm-riak-adapter_spec.rb

@@ -1,16 +1,281 @@
 $: << File.dirname(__FILE__)
 
 require 'spec_helper'
-require 'dm-core/spec/adapter_shared_spec'
 
 describe DataMapper::Adapters::RiakAdapter do
   before :all do
     @adapter = DataMapper.setup(:default, :adapter => 'riak', :namespace => 'test')
+    
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Key
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
   end
   
   after :all do
-    Heffalump.all.destroy
+    @adapter.flush Heffalump
+  end
+
+  describe '#create' do
+    it 'should not raise any errors' do
+      lambda {
+        Heffalump.create(:color => 'peach')
+      }.should_not raise_error
+    end
+
+    it 'should set the identity field for the resource' do
+      heffalump = Heffalump.new(:color => 'peach')
+      heffalump.id.should be_nil
+      heffalump.save
+      heffalump.id.should_not be_nil
+    end
+  end
+
+  describe '#read' do
+    before :all do
+      @heffalump = Heffalump.create(:color => 'brownish hue')
+      #just going to borrow this, so I can check the return values
+      @query = Heffalump.all.query
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        Heffalump.all()
+      }.should_not raise_error
+    end
+
+    it 'should return stuff' do
+      Heffalump.all.should be_include(@heffalump)
+    end
+  end
+
+  describe '#update' do
+    before do
+      @heffalump = Heffalump.create(:color => 'indigo')
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        @heffalump.color = 'violet'
+        @heffalump.save
+      }.should_not raise_error
+    end
+
+    it 'should not alter the identity field' do
+      id = @heffalump.id
+      @heffalump.color = 'violet'
+      @heffalump.save
+      @heffalump.id.should == id
+    end
+
+    it 'should update altered fields' do
+      @heffalump.color = 'violet'
+      @heffalump.save
+      Heffalump.get(*@heffalump.key).color.should == 'violet'
+    end
+
+    it 'should not alter other fields' do
+      color = @heffalump.color
+      @heffalump.num_spots = 3
+      @heffalump.save
+      Heffalump.get(*@heffalump.key).color.should == color
+    end
   end
 
-  it_should_behave_like 'An Adapter'
+  describe '#delete' do
+    before do
+      @heffalump = Heffalump.create(:color => 'forest green')
+    end
+
+    it 'should not raise any errors' do
+      lambda {
+        @heffalump.destroy
+      }.should_not raise_error
+    end
+
+    it 'should delete the requested resource' do
+      id = @heffalump.id
+      @heffalump.destroy
+      Heffalump.get(id).should be_nil
+    end
+  end
+
+  describe 'query matching' do
+    before :all do
+      @red = Heffalump.create(:color => 'red')
+      @two = Heffalump.create(:num_spots => 2)
+      @five = Heffalump.create(:num_spots => 5)
+    end
+
+    describe 'conditions' do
+      describe 'eql' do
+        it 'should be able to search for objects included in an inclusive range of values' do
+          Heffalump.all(:num_spots => 1..5).should be_include(@five)
+        end
+
+        it 'should be able to search for objects included in an exclusive range of values' do
+          Heffalump.all(:num_spots => 1...6).should be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an inclusive range of values' do
+          Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an exclusive range of values' do
+          Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+        end
+      end
+
+      describe 'not' do
+        it 'should be able to search for objects with not equal value' do
+          Heffalump.all(:color.not => 'red').should_not be_include(@red)
+        end
+
+        it 'should include objects that are not like the value' do
+          Heffalump.all(:color.not => 'black').should be_include(@red)
+        end
+
+        it 'should be able to search for objects with not nil value' do
+          Heffalump.all(:color.not => nil).should be_include(@red)
+        end
+
+        it 'should not include objects with a nil value' do
+          Heffalump.all(:color.not => nil).should_not be_include(@two)
+        end
+
+        it 'should be able to search for object with a nil value using required properties' do
+          Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+        end
+
+        it 'should be able to search for objects not in an empty list (match all)' do
+          Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+        end
+
+        it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+          Heffalump.all(:conditions => DataMapper::Query::Conditions::Operation.new(
+                                         :or,
+                                         DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                                         DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5]))).should == [ @five ]
+        end
+
+        it 'should be able to search for objects not included in an array of values' do
+          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+        end
+
+        it 'should be able to search for objects not included in an array of values' do
+          Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+        end
+
+        it 'should be able to search for objects not included in an inclusive range of values' do
+          Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+        end
+
+        it 'should be able to search for objects not included in an exclusive range of values' do
+          Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an inclusive range of values' do
+          Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+        end
+
+        it 'should not be able to search for values not included in an exclusive range of values' do
+          Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+        end
+      end
+
+      describe 'like' do
+        it 'should be able to search for objects that match value' do
+          Heffalump.all(:color.like => '%ed').should be_include(@red)
+        end
+
+        it 'should not search for objects that do not match the value' do
+          Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+        end
+      end
+
+      describe 'regexp' do
+        before do
+          if (defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+              defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+            pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+          end
+        end
+
+        it 'should be able to search for objects that match value' do
+          Heffalump.all(:color => /ed/).should be_include(@red)
+        end
+
+        it 'should not be able to search for objects that do not match the value' do
+          Heffalump.all(:color => /blak/).should_not be_include(@red)
+        end
+
+        it 'should be able to do a negated search for objects that match value' do
+          Heffalump.all(:color.not => /blak/).should be_include(@red)
+        end
+
+        it 'should not be able to do a negated search for objects that do not match value' do
+          Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+        end
+
+      end
+
+      describe 'gt' do
+        it 'should be able to search for objects with value greater than' do
+          Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+        end
+      end
+
+      describe 'gte' do
+        it 'should be able to search for objects with value greater than' do
+          Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+        end
+
+        it 'should be able to search for objects with values equal to' do
+          Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+        end
+      end
+
+      describe 'lt' do
+        it 'should be able to search for objects with value less than' do
+          Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+        end
+      end
+
+      describe 'lte' do
+        it 'should be able to search for objects with value less than' do
+          Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+        end
+
+        it 'should be able to search for objects with values equal to' do
+          Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+        end
+
+        it 'should not find objects with a value less than' do
+          Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+        end
+      end
+    end
+
+    describe 'limits' do
+      it 'should be able to limit the objects' do
+        Heffalump.all(:limit => 2).length.should == 2
+      end
+    end
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Mike Richards
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -04:00
+date: 2010-03-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,6 +54,8 @@ extra_rdoc_files: []
 files: 
 - README.md
 - lib/dm-riak-adapter.rb
+- lib/dm-riak-adapter/adapter.rb
+- lib/dm-riak-adapter/key.rb
 - spec/dm-riak-adapter_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true