datamapper 0.1.1 → 0.2.0

data/plugins/dataobjects/swig_sqlite/sqlite_c.i

@@ -0,0 +1,168 @@
+%module sqlite3_c
+%include "typemaps.i"
+%{
+#include <sqlite3.h>
+typedef void BLOB;
+typedef void VALBLOB;
+%}
+
+%typemap(in,numinputs=0) sqlite3 **OUTPUT(sqlite3 *) { 
+  $1 = (sqlite3**)malloc( sizeof( sqlite3* ) ); 
+};
+%typemap(argout,fragment="output_helper") sqlite3 **OUTPUT (sqlite3 *) {
+  $result = output_helper($result, SWIG_NewPointerObj( *$1, SWIGTYPE_p_sqlite3, 0 ));
+}
+%typemap(freearg) sqlite3 ** {
+  free((sqlite3 *)$1);
+}
+
+%typemap(in,numinputs=0) sqlite3_stmt **OUTPUT(sqlite3_stmt *) { 
+  $1 = (sqlite3_stmt**)malloc( sizeof( sqlite3_stmt* ) ); 
+};
+%typemap(argout,fragment="output_helper") sqlite3_stmt **OUTPUT (sqlite3_stmt *) {
+  $result = output_helper($result, SWIG_NewPointerObj( *$1, SWIGTYPE_p_sqlite3_stmt, 0 ));
+}
+%typemap(freearg) sqlite3_stmt ** {
+  free((sqlite3_stmt *)$1);
+}
+
+%typemap(in,numinputs=0) char **OUTPUT(char *) { 
+  $1 = (char**)malloc( sizeof( char* ) ); 
+};
+%typemap(argout,fragment="output_helper") char **OUTPUT (char *) {
+  $result = output_helper($result, rb_str_new2(*$1));
+}
+%typemap(freearg) char ** {
+  free((char *)$1);
+}
+
+%typemap(out) sqlite_int64 {
+  $result = LONG2NUM(result);
+}
+
+const char *sqlite3_libversion(void);
+int sqlite3_close(sqlite3*);
+
+sqlite_int64 sqlite3_last_insert_rowid(sqlite3*);
+
+int sqlite3_changes(sqlite3*);
+int sqlite3_total_changes(sqlite3*);
+void sqlite3_interrupt(sqlite3*);
+
+int sqlite3_complete(const char*);
+int sqlite3_complete16(const void *str);
+
+int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
+int sqlite3_busy_timeout(sqlite3*,int);
+int sqlite3_set_authorizer(sqlite3*, int(*)(void*,int,const char*,const char*,const char*,const char*), void*);
+int sqlite3_trace(sqlite3*, void(*)(void*,const char*), void*);
+
+int sqlite3_open(const char *filename, sqlite3 **OUTPUT);
+int sqlite3_open16(const void *filename, sqlite3 **);
+
+int sqlite3_errcode(sqlite3*);
+const char *sqlite3_errmsg(sqlite3*);
+const void *sqlite3_errmsg16(sqlite3*);
+
+int sqlite3_prepare(sqlite3*,const char* sql,int,sqlite3_stmt**OUTPUT,const char**OUTPUT);
+int sqlite3_prepare_v2(sqlite3*,const char* sql,int,sqlite3_stmt**OUTPUT,const char**OUTPUT);
+int sqlite3_prepare16(sqlite3*,const void* sql,int,sqlite3_stmt**,const void**);
+
+int sqlite3_bind_blob(sqlite3_stmt*,int,const void *blob,int,void(*free)(void*));
+int sqlite3_bind_double(sqlite3_stmt*,int,double);
+int sqlite3_bind_int(sqlite3_stmt*,int,int);
+int sqlite3_bind_int64(sqlite3_stmt*,int,sqlite_int64);
+int sqlite3_bind_null(sqlite3_stmt*,int);
+int sqlite3_bind_text(sqlite3_stmt*,int,const char*text,int,void(*free)(void*));
+int sqlite3_bind_text16(sqlite3_stmt*,int,const void*utf16,int,void(*free)(void*));
+
+int sqlite3_bind_parameter_count(sqlite3_stmt*);
+const char *sqlite3_bind_parameter_name(sqlite3_stmt*,int);
+int sqlite3_bind_parameter_index(sqlite3_stmt*,const char*);
+
+int sqlite3_column_count(sqlite3_stmt*);
+const char *sqlite3_column_name(sqlite3_stmt*,int);
+const void *sqlite3_column_name16(sqlite3_stmt*,int);
+const char *sqlite3_column_decltype(sqlite3_stmt*,int);
+const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
+
+int sqlite3_step(sqlite3_stmt*);
+
+int sqlite3_data_count(sqlite3_stmt*);
+
+const BLOB *sqlite3_column_blob(sqlite3_stmt*,int);
+int sqlite3_column_bytes(sqlite3_stmt*,int);
+int sqlite3_column_bytes16(sqlite3_stmt*,int);
+double sqlite3_column_double(sqlite3_stmt*,int);
+double sqlite3_column_int(sqlite3_stmt*,int);
+sqlite_int64 sqlite3_column_int64(sqlite3_stmt*,int);
+const char *sqlite3_column_text(sqlite3_stmt*,int);
+const void *sqlite3_column_text16(sqlite3_stmt*,int);
+int sqlite3_column_type(sqlite3_stmt*,int);
+
+int sqlite3_finalize(sqlite3_stmt*);
+int sqlite3_reset(sqlite3_stmt*);
+
+int sqlite3_create_function(sqlite3*,const char*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*));
+
+int sqlite3_create_function16(sqlite3*,const void*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*));
+
+int sqlite3_aggregate_count(sqlite3_context*);
+
+const VALBLOB *sqlite3_value_blob(sqlite3_value*);
+int sqlite3_value_bytes(sqlite3_value*);
+int sqlite3_value_bytes16(sqlite3_value*);
+double sqlite3_value_double(sqlite3_value*);
+int sqlite3_value_int(sqlite3_value*);
+sqlite_int64 sqlite3_value_int64(sqlite3_value*);
+const char *sqlite3_value_text(sqlite3_value*);
+const void *sqlite3_value_text16(sqlite3_value*);
+const void *sqlite3_value_text16le(sqlite3_value*);
+const void *sqlite3_value_text16be(sqlite3_value*);
+int sqlite3_value_type(sqlite3_value*);
+
+void sqlite3_result_blob(sqlite3_context*,const void *blob,int,void(*free)(void*));
+void sqlite3_result_double(sqlite3_context*,double);
+void sqlite3_result_error(sqlite3_context*,const char *text,int);
+void sqlite3_result_error16(sqlite3_context*,const void *blob,int);
+void sqlite3_result_int(sqlite3_context*,int);
+void sqlite3_result_int64(sqlite3_context*,sqlite_int64);
+void sqlite3_result_text(sqlite3_context*,const char* text,int,void(*free)(void*));
+void sqlite3_result_text16(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_text16le(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_text16be(sqlite3_context*,const void* utf16,int,void(*free)(void*));
+void sqlite3_result_value(sqlite3_context*,sqlite3_value*);
+
+VALUE *sqlite3_aggregate_context(sqlite3_context*,int data_size);
+
+#define SQLITE_OK           0   /* Successful result */
+/* beginning-of-error-codes */
+#define SQLITE_ERROR        1   /* SQL error or missing database */
+#define SQLITE_INTERNAL     2   /* NOT USED. Internal logic error in SQLite */
+#define SQLITE_PERM         3   /* Access permission denied */
+#define SQLITE_ABORT        4   /* Callback routine requested an abort */
+#define SQLITE_BUSY         5   /* The database file is locked */
+#define SQLITE_LOCKED       6   /* A table in the database is locked */
+#define SQLITE_NOMEM        7   /* A malloc() failed */
+#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
+#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
+#define SQLITE_FULL        13   /* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
+#define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */
+#define SQLITE_EMPTY       16   /* Database is empty */
+#define SQLITE_SCHEMA      17   /* The database schema changed */
+#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
+#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
+#define SQLITE_MISMATCH    20   /* Data type mismatch */
+#define SQLITE_MISUSE      21   /* Library used incorrectly */
+#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
+#define SQLITE_AUTH        23   /* Authorization denied */
+#define SQLITE_FORMAT      24   /* Auxiliary database format error */
+#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
+#define SQLITE_NOTADB      26   /* File opened that is not a database file */
+#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
+#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
+/* end-of-error-codes */

data/rakefile.rb

@@ -6,25 +6,36 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
-task :default => 'test'
+Dir[File.dirname(__FILE__) + '/tasks/*'].each { |t| require(t) }
 
-desc "Run specifications"
-Spec::Rake::SpecTask.new('test') do |t|
-  t.spec_opts = [ '-rspec/spec_helper' ]
-  t.spec_files = FileList['spec/*.rb', (ENV['FILES'] || 'spec/**/*_spec.rb')]
-end
+task :default => 'dm:spec'
 
-desc "Run comparison with ActiveRecord"
-task :perf do
-  load 'performance.rb'
-end
+namespace :dm do
+
+  desc "Setup Environment"
+  task :environment do
+    require 'environment'
+  end
+  
+  desc "Run specifications"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_opts = [ '-rspec/spec_helper' ]
+    t.spec_files = FileList[(ENV['FILES'] || 'spec/**/*_spec.rb')]
+  end
+
+  desc "Run comparison with ActiveRecord"
+  task :perf do
+    load 'performance.rb'
+  end
+
+  desc "Profile DataMapper"
+  task :profile do
+    load 'profile_data_mapper.rb'
+  end
 
-desc "Profile DataMapper"
-task :profile do
-  load 'profile_data_mapper.rb'
 end
 
-PACKAGE_VERSION = '0.1.1'
+PACKAGE_VERSION = '0.2.0'
 
 PACKAGE_FILES = FileList[
   'README',
@@ -32,40 +43,47 @@ PACKAGE_FILES = FileList[
   'MIT-LICENSE',
   '*.rb',
   'lib/**/*.rb',
-  'spec/**/*.{rb,yaml}'
+  'spec/**/*.{rb,yaml}',
+  'tasks/**/*',
+  'plugins/**/*'
 ].to_a
 
 PROJECT = 'datamapper'
 
+task :ls do
+  p PACKAGE_FILES.reject { |path| path =~ /(^spec|\/spec|\/swig\_)/ }.sort
+end
+
 desc "Generate Documentation"
 rd = Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title = "DataMapper -- An Object/Relational Mapper for Ruby"
   rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include(PACKAGE_FILES.reject { |path| path =~ /^(spec|\w+\.rb)/ })
+  rdoc.rdoc_files.include(PACKAGE_FILES.reject { |path| path =~ /(^spec|\/spec|\/swig\_)/ })
 end
 
-gem_spec = Gem::Specification.new do |s| 
+gem_spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY 
   s.name = PROJECT 
   s.summary = "An Object/Relational Mapper for Ruby"
-  s.description = "It's ActiveRecord, but Faster, Better, Simpler."
+  s.description = "Faster, Better, Simpler."
   s.version = PACKAGE_VERSION 
-   
+ 
   s.authors = 'Sam Smoot'
   s.email = 'ssmoot@gmail.com'
   s.rubyforge_project = PROJECT 
   s.homepage = 'http://datamapper.org' 
-   
+ 
   s.files = PACKAGE_FILES 
-   
+ 
   s.require_path = 'lib'
   s.requirements << 'none'
   s.autorequire = 'data_mapper'
+  s.add_dependency('fastthread')
 
   s.has_rdoc = true 
   s.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README' 
-  s.extra_rdoc_files = rd.rdoc_files.reject { |path| path =~ /\.rb$/ }.to_a 
+  s.extra_rdoc_files = PACKAGE_FILES.reject { |path| path =~ /(^spec|\/spec|\/swig\_)/ }.to_a 
 end
 
 Rake::GemPackageTask.new(gem_spec) do |p|
@@ -76,5 +94,9 @@ end
 
 desc "Publish to RubyForge"
 task :rubyforge => [ :rdoc, :gem ] do
-  Rake::SshDirPublisher.new(ENV['RUBYFORGE_USER'], "/var/www/gforge-projects/#{PROJECT}", 'doc').upload
+  Rake::SshDirPublisher.new("#{ENV['RUBYFORGE_USER']}@rubyforge.org", "/var/www/gforge-projects/#{PROJECT}", 'doc').upload
+end
+
+task :install => :package do
+  sh %{sudo gem install pkg/#{PROJECT}-#{PACKAGE_VERSION}}
 end

data/spec/acts_as_tree_spec.rb

@@ -0,0 +1,39 @@
+describe('A tree') do
+  
+  before(:all) do
+    class Node < DataMapper::Base
+      property :name, :string
+
+      belongs_to :parent, :class => 'Node'
+      has_many :children, :class => 'Node', :foreign_key => 'parent_id'
+    end
+    
+    database.schema[Node].drop!
+    database.save(Node)
+  end    
+
+  it 'should work' do
+    root = Node.new(:name => 'root')
+
+    one = Node.new(:name => 'one')
+    two = Node.new(:name => 'two')
+
+    root.children << one << two
+
+    one_one = Node.new(:name => 'one_one')
+    one_two = Node.new(:name => 'one_two')
+    one.children << one_one << one_two
+
+    two_one = Node.new(:name => 'two_one')
+    two_two = Node.new(:name => 'two_two')
+    two.children << two_one << two_two
+
+    root.save
+
+    grand = Node[:name => 'root']
+    root.should_not == grand # false since +root+ and +grand+ are in different sessions.
+
+    grand.children[0].children[0].name.should == 'one_one'
+  end
+  
+end

data/spec/associations_spec.rb

@@ -0,0 +1,220 @@
+describe DataMapper::Associations::BelongsToAssociation do
+  before(:each) do
+    @aviary = Exhibit[:name => 'Monkey Mayhem']
+  end
+  
+  it 'has a zoo association' do
+    @aviary.zoo.class.should == Zoo
+    Exhibit.new.zoo.should == nil
+  end
+  
+  it 'belongs to a zoo' do
+    @aviary.zoo.should == @aviary.session.first(Zoo, :name => 'San Diego')
+  end
+  
+  it "is assigned a zoo_id" do
+    zoo = Zoo.first
+    exhibit = Exhibit.new(:name => 'bob')
+    exhibit.zoo = zoo
+    exhibit.instance_variable_get("@zoo_id").should == zoo.id    
+  end
+  
+  it 'can build its zoo' do
+    database do |db|
+      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
+      e.zoo.should == nil
+      e.build_zoo({:name => 'Monkey Zoo'})
+      e.zoo.class == Zoo
+      e.zoo.new_record?.should == true
+      
+      e.save
+    end
+  end
+  
+  it 'can build its zoo' do
+    database do |db|
+      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
+      e.zoo.should == nil
+      e.create_zoo({:name => 'Monkey Zoo'})
+      e.zoo.class == Zoo
+      e.zoo.new_record?.should == false
+      e.save
+    end
+  end
+  
+  after(:all) do
+    fixtures('zoos')
+    fixtures('exhibits')
+  end
+end
+
+describe DataMapper::Associations::HasManyAssociation do
+  
+  before(:all) do
+    fixtures(:zoos)
+    fixtures(:exhibits)
+  end
+
+  before(:each) do
+    @zoo = Zoo.new(:name => "ZOO")
+    @zoo.save 
+  end
+  
+  after(:each) do
+    @zoo.destroy!
+  end
+  
+  it 'should lazily-load the association when Enumerable methods are called' do
+    database do |db|
+      san_diego = Zoo[:name => 'San Diego']
+      san_diego.exhibits.size.should == 2
+      san_diego.exhibits.should include(Exhibit[:name => 'Monkey Mayhem'])
+    end
+  end
+  
+  it 'should eager-load associations for an entire set' do
+    database do
+      zoos = Zoo.all
+      zoos.each do |zoo|
+        zoo.exhibits.each do |exhibit|
+          exhibit.zoo.should == zoo
+        end
+      end
+    end
+  end
+  
+  it "should be dirty even when clean objects are associated" do
+    zoo = Zoo[:name => 'New York']
+    zoo.exhibits << Exhibit.first
+    zoo.should be_dirty
+  end
+  
+  it "should proxy associations on the associated type" do
+    Zoo[:name => 'Miami'].exhibits.animals.size.should == 1
+  end
+  
+  it "should have a valid zoo setup for testing" do
+    @zoo.should be_valid
+    @zoo.should_not be_a_new_record
+    @zoo.id.should_not be_nil
+  end  
+  
+  it "should generate the SQL for a join statement" do
+    exhibits_association = database(:mock).schema[Zoo].associations.find { |a| a.name == :exhibits }
+  
+    exhibits_association.to_sql.should == <<-EOS.compress_lines
+      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
+    EOS
+  end
+  
+  it "should add an item to an association" do
+    bear = Exhibit.new( :name => "Bear")
+    @zoo.exhibits << bear
+    @zoo.exhibits.should include(bear)
+  end
+
+  
+  it "should set the association to a saved target when added with <<" do    
+    pirahna = Exhibit.new(:name => "Pirahna")
+    pirahna.zoo_id.should be_nil
+    
+    @zoo.exhibits << pirahna
+    pirahna.zoo.should == @zoo
+  end
+  
+  it "should set the association to a non-saved target when added with <<" do
+    zoo = Zoo.new(:name => "My Zoo")
+    kangaroo = Exhibit.new(:name => "Kangaroo")
+    zoo.exhibits << kangaroo
+    kangaroo.zoo.should == zoo
+  end
+  
+  it "should set the id of the exhibit when the associated zoo is saved" do
+    snake = Exhibit.new(:name => "Snake")
+    @zoo.exhibits << snake
+    @zoo.save
+    @zoo.id.should == snake.zoo_id
+  end
+  
+  it "should set the id of an already saved exibit if it's added to a different zoo" do
+    beaver = Exhibit.new(:name => "Beaver")
+    beaver.save
+    beaver.should_not be_a_new_record
+    @zoo.exhibits << beaver
+    @zoo.save
+    beaver.zoo.should == @zoo
+    beaver.zoo_id.should == @zoo.id    
+  end
+  
+  it "should set the size of the assocation" do
+    @zoo.exhibits << Exhibit.new(:name => "anonymous")
+    @zoo.exhibits.size.should == 1
+  end
+  
+  it "should give the association when an inspect is done on it" do
+    whale = Exhibit.new(:name => "Whale")
+    @zoo.exhibits << whale
+    @zoo.exhibits.should_not == "nil"
+    @zoo.exhibits.inspect.should_not be_nil
+  end
+end
+
+describe DataMapper::Associations::HasOneAssociation do
+  
+  it "should generate the SQL for a join statement" do
+    fruit_association = database(:mock).schema[Animal].associations.find { |a| a.name == :favourite_fruit }
+  
+    fruit_association.to_sql.should == <<-EOS.compress_lines
+      JOIN `fruit` ON `fruit`.`devourer_id` = `animals`.`id`
+    EOS
+  end
+
+end
+
+describe DataMapper::Associations::HasAndBelongsToManyAssociation do
+
+  before(:all) do
+    fixtures(:animals)
+    fixtures(:exhibits)
+  end
+  
+  before(:each) do
+    @amazonia = Exhibit[:name => 'Amazonia']
+  end
+  
+  it "should generate the SQL for a join statement" do
+    animals_association = database(:mock).schema[Exhibit].associations.find { |a| a.name == :animals }
+  
+    animals_association.to_sql.should == <<-EOS.compress_lines
+      JOIN `animals_exhibits` ON `animals_exhibits`.`exhibit_id` = `exhibits`.`id`
+      JOIN `animals` ON `animals`.`id` = `animals_exhibits`.`animal_id`
+    EOS
+  end
+  
+  it "should load associations" do
+    database do
+      froggy = Animal[:name => 'Frog']
+      froggy.exhibits.size.should == 1
+      froggy.exhibits.entries.first.should == Exhibit[:name => 'Amazonia']
+    end
+  end
+  
+  it 'has an animals association' do
+    [@amazonia, Exhibit.new].each do |exhibit|
+      exhibit.animals.class.should == DataMapper::Associations::HasAndBelongsToManyAssociation::Set
+    end
+  end
+  
+  it 'has many animals' do
+    @amazonia.animals.size.should == 1
+  end
+  
+  it 'should load associations magically' do
+    Exhibit.all.each do |exhibit|
+      exhibit.animals.each do |animal|
+        animal.exhibits.should include(exhibit)
+      end
+    end
+  end
+
+end