dm-waztables-adapter 0.1.0

data/lib/dm-waztables-adapter.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+if defined?(gem)
+  gem 'dm-core', '~> 0.10.2'
+  gem 'waz-storage', '~> 1.0.0'
+end
+
+require 'dm-core'
+require 'waz-tables'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'dm-waztables-adapter/version'
+require 'dm-waztables-adapter/adapter'
+require 'dm-waztables-adapter/migrations'

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

@@ -0,0 +1,85 @@
+module DataMapper
+  module WAZTables
+    class Adapter < DataMapper::Adapters::AbstractAdapter
+      # @api semipublic
+      def initialize(name, options = {})
+        super
+        WAZ::Storage::Base.establish_connection!(:account_name => options[:account_name], :access_key => options[:access_key])
+      end
+
+      # @api semipublic      
+      def create(resources)
+        service = WAZ::Tables::Table.service_instance
+        resources.each do |resource|
+          entity = {:row_key => resource.key.first}
+          entity.merge!({:partition_key => resource.model.storage_name})
+          resource.attributes.each { |a| entity.merge!({ a[0].to_sym => a[1] }) }
+          service.insert_entity(resource.model.storage_name, entity)
+        end
+        resources.size
+      end
+
+      # @api semipublic
+      def read(query)
+        service = WAZ::Tables::Table.service_instance
+        operator_mapping = {:gt => 'gt', :lt => 'lt', :gte => 'ge', :lte => 'le', :not => 'ne', :eql => 'eq'}
+
+        conditions = query.conditions.map do |c|
+          unless (c.class.name.eql?('Array'))
+            case c.slug
+              when :not then 
+                "(#{c.operand.to_s.gsub(%r{=}, operator_mapping[c.slug]).gsub(%r{"}, "'")})"              
+              when :like then
+                # 
+                name, value = c.subject.name, c.value.delete('%')
+                (c.value =~ /^%/) ? "endswith(#{name}, '#{value}')" : ((c.value =~ /%$/) ? "startswith(#{name}, '#{value}')" : "(#{name} eq '#{value}')")
+              when :regexp then
+              else 
+                "(#{c.subject.name} #{operator_mapping[c.slug]} #{c.value.class.name =~ /Fixnum|Float|Bignum/ ? c.value : "'#{c.value}'"})"
+            end
+          else
+            query.conditions
+          end
+        end
+
+        query_options = {:expression => conditions.sort.compact.join(' and ')}
+        query_options.merge!({:top => query.limit}) if query.limit
+
+        result = service.query(query.model.storage_name, query_options)
+
+        records = result.map do |item|
+          record = {}
+          item.each { |k,v| record.merge!( { k.to_s => v } ) }
+          record
+        end
+        
+        query.filter_records(records)
+      end
+
+      # @api semipublic
+      def update(attributes, resources)
+        service = WAZ::Tables::Table.service_instance
+        resources.each do |resource|
+          entity = service.get_entity(resource.model.storage_name, resource.model.storage_name, resource.id)
+          attributes.each do |attribute|
+            entity[attribute[0].name] = attribute[1]
+          end
+          entity = service.update_entity(resource.model.storage_name, entity)
+        end
+        resources.size
+      end
+
+      # @api semipublic
+      def delete(resources)
+        service = WAZ::Tables::Table.service_instance
+        resources.each do |resource|
+          service.delete_entity(resource.model.storage_name, resource.model.storage_name, resource.id)
+        end
+        resources.size
+      end
+    end
+  end
+  
+  Adapters::WAZTablesAdapter = DataMapper::WAZTables::Adapter
+  Adapters.const_added(:WAZTablesAdapter)        
+end

data/lib/dm-waztables-adapter/migrations.rb

@@ -0,0 +1,32 @@
+module DataMapper
+  module WAZTables
+    module Migrations
+      def self.included(base)
+        DataMapper.extend(DataMapper::Migrations::SingletonMethods)
+        [ :Repository, :Model ].each do |name|
+          DataMapper.const_get(name).send(:include, DataMapper::Migrations.const_get(name))
+        end
+      end
+ 
+      def storage_exists?(storage_name)
+        WAZ::Tables::Table.find(storage_name)
+      end
+ 
+      def create_model_storage(model)
+        WAZ::Tables::Table.create(model.storage_name)
+      end
+ 
+      def upgrade_model_storage(model)
+        WAZ::Tables::Table.create(model.storage_name) unless self.storage_exists?(model.storage_name)
+      end
+ 
+      def destroy_model_storage(model)
+        return unless (model_storage = self.storage_exists?(model.storage_name))
+        model_storage.destroy!
+      end
+    end
+  end
+end
+ 
+DataMapper::WAZTables.send(:include, DataMapper::WAZTables::Migrations)
+DataMapper::WAZTables::Adapter.send(:include, DataMapper::WAZTables::Migrations)

data/lib/dm-waztables-adapter/version.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  module WAZTables
+    module VERSION #:nodoc:
+      MAJOR    = '0'
+      MINOR    = '1'
+      TINY     = '0' 
+    end
+    
+    Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'    
+  end
+end

data/rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+require 'lib/dm-waztables-adapter'
+
+namespace :test do
+  Spec::Rake::SpecTask.new('run_with_rcov') do |t|
+    t.spec_files = FileList['spec/*.rb'].reject{|f| f.include?('functional')}
+    t.rcov = true
+    t.rcov_opts = ['--text-report', '--exclude', "exclude.*/.gem,spec,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
+    t.spec_opts = ['-cfn']
+  end
+end
+
+namespace :dist do  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'dm-waztables-adapter'
+    s.version           = Gem::Version.new(DataMapper::WAZTables::Version)
+    s.summary           = "DataMapper adapter for Windows Azure Table Services"
+    s.description       = "Adapter created to use the Windows Azure Table Services leveraging the simplicity of DataMapper"
+    s.email             = 'juanpablogarcia@gmail.com'
+    s.author            = 'Juan Pablo Garcia Dalolla'
+    s.homepage          = 'http://github.com/jpgarcia/dm-waztables-adapter'
+    s.require_paths     = ["lib"]
+    s.files             = FileList['rakefile', 'lib/**/*.rb']
+    s.test_files        = Dir['spec/**/*']
+    s.has_rdoc          = true
+    s.rdoc_options      << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+    
+    # Dependencies
+    s.add_dependency 'waz-storage', '>= 1.0.0'
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
+end

data/spec/adapter_spec.rb

@@ -0,0 +1,132 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+require 'spec/spec_helpers'
+require 'lib/dm-waztables-adapter'
+
+describe "DataMapper adapter for Windows Azure Tables behavior" do
+  it "should setup datamapper with WAZTables adapter" do
+    WAZ::Storage::Base.expects(:establish_connection!).with({:account_name => 'account_name', :access_key => 'access_key'})
+    DataMapper.setup(:default, { :adapter => 'WAZTables',
+                                 :account_name => 'account_name',
+                                 :access_key => 'access_key'})
+
+    Guitarist.repository.adapter.options[:adapter].should == 'WAZTables'
+  end
+  
+  it "should insert a new resource" do
+    mock_service = mock()
+    mock_entity = {:row_key => '1', :partition_key => 'guitarists', :id => '1', :name => 'Jimi Hendrix', :age => nil}
+    mock_service.expects(:insert_entity).with('guitarists', mock_entity)
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    guitarist = Guitarist.create({:id => '1', :name => 'Jimi Hendrix'})
+    guitarist.should_not be_nil
+  end
+  
+  it "should update a resource" do
+    mock_service = mock()
+    original = {:row_key => '2', :partition_key => 'guitarists', :id => '2', :name => 'some_name', :age => 23}    
+    updated = {:row_key => '2', :partition_key => 'guitarists', :id => '2', :name => 'Joe Satriani', :age => 33}    
+    mock_service.expects(:get_entity).with('guitarists', 'guitarists', '2').returns(original)
+    mock_service.expects(:update_entity).with('guitarists', updated).returns(updated)
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+
+    mock_guitarist = Guitarist.new({:id => '2', :name => 'some_name', :age => 23})
+    mock_guitarist.stubs(:saved?).returns(true)
+    
+    Guitarist.stubs(:get).with('2').returns(mock_guitarist)
+
+    guitarist = Guitarist.get('2')
+    guitarist.name = 'Joe Satriani'
+    guitarist.age = 33
+    guitarist.save
+  end
+  
+  it "should delete a resource" do
+    mock_service = mock()
+    mock_service.expects(:delete_entity).with('guitarists', 'guitarists', '3')
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+
+    mock_guitarist = Guitarist.new({:id => '3', :name => 'Eric Clapton', :age => 23})
+    mock_guitarist.stubs(:saved?).returns(true)
+    
+    Guitarist.stubs(:get).with('3').returns(mock_guitarist)    
+    
+    guitarist = Guitarist.get('3')
+    guitarist.destroy
+  end
+  
+  it "should get only one record when calling get with a given id" do
+    mock_service = mock()
+    mock_result = [{ :id => '4', :name => 'Zakk Wylde', :age => 43 }]
+    mock_service.expects(:query).with('guitarists', {:expression => "(id eq '4')", :top => 1}).returns(mock_result)
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+
+    guitarist = Guitarist.get('4')
+    guitarist.id.should == '4'
+    guitarist.name.should == 'Zakk Wylde'
+    guitarist.age.should == 43
+  end
+    
+  it "should parse all conditions as well" do
+    mock_service = mock()
+    mock_result = [ { :id => '5', :name => 'Mark Knopfler', :age => 62 } ]
+    expected_expression = "(age ge 20) and (age gt 19) and (age le 70) and (age lt 71) and (name eq 'Mark Knopfler') and (name ne 'Mar Knofler')"
+    mock_service.expects(:query).with('guitarists', {:expression => expected_expression}).returns(mock_result)
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    guitarists = Guitarist.all({ :age.gte => 20, :age.lte => 70, :age.gt => 19, :age.lt => 71, :name => 'Mark Knopfler', :name.not => 'Mar Knofler'})
+    guitarists.length.should == 1
+    
+    guitarists.first.id.should == '5'
+    guitarists.first.name.should == 'Mark Knopfler'
+    guitarists.first.age.should == 62
+  end
+  
+  it "should query with startswith filters when using like" do
+    mock_service = mock()
+    mock_result = [ { :id => '6', :name => 'Glenn Tipton', :age => 62 } ]
+    mock_service.expects(:query).with('guitarists', { :expression => "startswith(name, 'Glen')" }).returns(mock_result)
+
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    Guitarist.all({ :name.like => 'Glen%' }).length.should == 1
+  end
+  
+  it "should query with endswith filters when using like" do
+    mock_service = mock()
+    mock_result = [ { :id => '6', :name => 'Glenn Tipton', :age => 62 } ]
+    mock_service.expects(:query).with('guitarists', { :expression => "endswith(name, 'Tipton')" }).returns(mock_result)
+
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    Guitarist.all({ :name.like => '%Tipton' }).length.should == 1
+  end
+  
+  it "should query with eq when using like without % sign" do
+    mock_service = mock()
+    mock_result = [ { :id => '6', :name => 'Glenn Tipton', :age => 62 } ]
+    mock_service.expects(:query).with('guitarists', { :expression => "(name eq 'Glenn Tipton')" }).returns(mock_result)
+    
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    Guitarist.all({ :name.like => 'Glenn Tipton' }).length.should == 1
+  end
+
+  it "should include top option when providing :limit option" do
+    mock_service = mock()
+    mock_result = [ { :id => '6', :name => 'Glenn Tipton', :age => 62 }, { :id => '2', :name => 'K. K. Downing', :age => 58 } ]
+    mock_service.expects(:query).with('guitarists', { :expression => "(age ge 58)", :top => 10 }).returns(mock_result)
+
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    Guitarist.all({ :age.gte => 58, :limit => 10 }).length.should == 2
+  end
+  
+  it "should recieve a raw query using :conditions option" do
+    mock_service = mock()
+    mock_result = [ { :id => '6', :name => 'Glenn Tipton', :age => 62 }, { :id => '2', :name => 'K. K. Downing', :age => 58 } ]
+    mock_service.expects(:query).with('guitarists', { :expression => "((age ge 50) and (age lt 100))" }).returns(mock_result)
+
+    WAZ::Tables::Table.expects(:service_instance).returns(mock_service)
+    Guitarist.all({ :conditions => ['(age ge 50) and (age lt 100)'] }).length.should == 2
+  end
+end

data/spec/functional_spec.rb

@@ -0,0 +1,58 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+
+require 'lib/dm-waztables-adapter'
+
+describe "WAZTables adapter functional tests" do
+  it "should satisfy my expectations" do
+    DataMapper.setup(:default, { :adapter => 'WAZTables',
+                                 :account_name => ENV['AZURE_ACCOUNT_NAME_JPGD'],
+                                 :access_key => ENV['AZURE_ACCESS_KEY_JPGD']})
+
+    # define a new model
+    class Guitarist
+     include DataMapper::Resource
+
+     property :id, String, :key => true
+     property :name, String
+     property :age, Integer
+    end
+
+    Guitarist.auto_upgrade!
+    Guitarist.all.destroy!
+
+    Guitarist.all.length.should == 0
+
+    # creating a new record
+    Guitarist.create(:id => '1', :name => 'Ritchie Blackmore', :age => 65)
+
+    # creating a new record
+    yngwie = Guitarist.new(:id => '2', :name => 'Yngwio Malmsteen', :age => 46)
+    yngwie.name = "Yngwie Malmsteen"
+    yngwie.save
+    
+    # retrieving a unique record by its id
+    ritchie = Guitarist.get('1')
+    ritchie.age.should == 65
+    ritchie.name.should == "Ritchie Blackmore"
+
+    # updating records
+    ritchie.age = 66
+    ritchie.save
+
+    # retrieving all guitarists
+    guitar_players = Guitarist.all
+    guitar_players.length.should == 2
+    guitar_players.first.name.should == "Ritchie Blackmore"
+    guitar_players.first.age.should == 66
+    guitar_players.last.name.should == "Yngwie Malmsteen"
+    guitar_players.last.age.should == 46
+        
+    # performing queries
+    older_guitar_players = Guitarist.all({ :age.gte => 50 })
+    older_guitar_players.length.should == 1
+
+    # deleting records
+    older_guitar_players.destroy!
+    Guitarist.all.length.should == 1
+  end
+end

data/spec/migrations_spec.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+require 'spec/spec_helpers'
+require 'lib/dm-waztables-adapter'
+
+describe "DataMapper Migrations for Model level behavior" do
+  it "should remove an existing Azure Table and create a new one" do
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(nil)    
+    WAZ::Tables::Table.expects(:destroy!).never()
+    WAZ::Tables::Table.expects(:create).with('guitarists').returns(mock())    
+    Guitarist.auto_migrate!
+  end
+
+  it "should just create a new Azure Table" do
+    mock_table = WAZ::Tables::Table.new(:name => 'guitarists', :url => 'url')
+    mock_table.expects(:destroy!)
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(mock_table)
+    WAZ::Tables::Table.expects(:create).with('guitarists').returns(mock())    
+    Guitarist.auto_migrate!
+  end
+  
+  it "should create a new Azure Table only if it doesn't exist" do
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(nil)
+    WAZ::Tables::Table.expects(:destroy!).never()
+    WAZ::Tables::Table.expects(:create).with('guitarists').returns(mock())    
+    Guitarist.auto_upgrade!
+  end
+  
+  it "should create a new Azure Table when it doesn't exist" do
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(mock())
+    WAZ::Tables::Table.expects(:destroy!).never()    
+    WAZ::Tables::Table.expects(:create).with('guitarists').never()
+    Guitarist.auto_upgrade!
+  end
+end
+
+describe "DataMapper Migrations for Repository level behavior" do
+  it "should remove existing Azure Tables and create new ones" do
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(nil)
+    WAZ::Tables::Table.expects(:destroy!).never()
+    WAZ::Tables::Table.expects(:create).with('guitarists').returns(mock())
+
+    mock_table = WAZ::Tables::Table.new(:name => 'guitars', :url => 'url')
+    mock_table.expects(:destroy!)
+    WAZ::Tables::Table.expects(:find).with('guitars').returns(mock_table)
+    WAZ::Tables::Table.expects(:create).with('guitars').returns(mock())
+    DataMapper.auto_migrate!
+  end
+  
+  it "should create only if a Table doesn't exist" do
+    WAZ::Tables::Table.expects(:find).with('guitarists').returns(nil)
+    WAZ::Tables::Table.expects(:destroy!).never()
+    WAZ::Tables::Table.expects(:create).with('guitarists').returns(mock())
+
+    WAZ::Tables::Table.expects(:find).with('guitars').returns(mock())
+    WAZ::Tables::Table.expects(:destroy!).never()
+    WAZ::Tables::Table.expects(:create).never()
+    DataMapper.auto_upgrade!
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format progress
+--backtrace

data/spec/spec_helpers.rb

@@ -0,0 +1,25 @@
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+
+  config.before :each do
+    class Guitarist
+      include DataMapper::Resource
+
+      property :id, String, :key => true
+      property :name, String
+      property :age, Integer
+    end
+
+    class Guitar
+      include DataMapper::Resource
+
+      property :id, String, :key => true
+      property :brand, String
+    end
+    DataMapper.setup(:default, { :adapter => 'WAZTables', :name => 'db', :account_name => 'n', :access_key => 'k'})
+  end
+ 
+  config.after :each do
+    DataMapper::Repository.adapters.delete(:default)
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: dm-waztables-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Juan Pablo Garcia Dalolla
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-08 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: waz-storage
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: Adapter created to use the Windows Azure Table Services leveraging the simplicity of DataMapper
+email: juanpablogarcia@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- lib/dm-waztables-adapter/adapter.rb
+- lib/dm-waztables-adapter/migrations.rb
+- lib/dm-waztables-adapter/version.rb
+- lib/dm-waztables-adapter.rb
+has_rdoc: true
+homepage: http://github.com/jpgarcia/dm-waztables-adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- -A cattr_accessor=object
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: DataMapper adapter for Windows Azure Table Services
+test_files: 
+- spec/adapter_spec.rb
+- spec/functional_spec.rb
+- spec/migrations_spec.rb
+- spec/spec.opts
+- spec/spec_helpers.rb