rod 0.6.1 → 0.6.2

data/.gitignore

@@ -0,0 +1,7 @@
+.*.sw?
+tmp
+work
+*.gem
+Gemfile.lock
+.bundle
+pkg

data/{README → README.rdoc}

@@ -7,7 +7,7 @@
 ROD (Ruby Object Database) is library which aims at providing
 fast access for data, which rarely changes.
 
-== FEATURES/PROBLEMS:
+== FEATURES:
 
 * nice Ruby interface which mimicks Active Record
 * Ruby-to-C on-the-fly translation based on mmap and RubyInline
@@ -21,8 +21,11 @@ fast access for data, which rarely changes.
 * append of the database (new objects, new elements in plural associations)
 * databases interlinking (via direct links or inverted indices)
 
+== PROBLEMS
+
+* tested mostly on 64-bit systems
 * doesn't work on Windows
-* some space is wasted during when database is appended
+* some space is wasted when database is re-opended in read/write mode
 
 == SYNOPSIS:
 
@@ -44,6 +47,7 @@ number of disk reads was designed. The Ruby interface facilitates it's usage.
 
 == REQUIREMENTS:
 
+* Ruby 1.9
 * RubyInline
 * english
 * ActiveModel
@@ -118,6 +122,33 @@ Grab from rubygems:
  User.find_all_by_surname("Smith") # gives [Fred]
  File[0].user                      # won't work - the data is not normalized
 
+== DEVELOPMENT
+
+You'll need bundler installed:
+
+  gem install bundler
+
+Then you have to fetch all the dependencies:
+
+  bunlde
+
+To run all the test simple type rake:
+
+  rake
+
+This might take several minutes, since for each scenario a whole set of C files
+have to compiled and linked. 
+
+During development you should watch your ~/.ruby_inline directory. If there
+are thousands of files there, you should fill a bug, since most of them should
+be automatically destroyed.
+
+If you want to implement a feature/fix a bug, first be sure that it is 
+documented on the bug tracker: https://github.com/apohllo/rod/issues.
+Then be sure to write tests covering the added feature/fixed bug. 
+Include the tests in Rakefile, run the tests and if everything is fine
+send me a pull request.
+
 == LICENSE:
 
 (The MIT License)

data/Rakefile

@@ -6,7 +6,7 @@ task :default => [:all_tests]
 $gem_name = "rod"
 
 desc "Build the gem"
-task :build => :all_tests do
+task :build do
   sh "gem build #$gem_name.gemspec"
   FileUtils.mkdir("pkg") unless File.exist?("pkg")
   sh "mv '#$gem_name-#{Rod::VERSION}.gem' pkg"
@@ -14,7 +14,12 @@ end
 
 desc "Install the library at local machnie"
 task :install => :build do 
-  sh "sudo gem install pkg/#$gem_name-#{Rod::VERSION}.gem"
+  sh "gem install pkg/#$gem_name-#{Rod::VERSION}.gem"
+end
+
+desc "Push gem to rubygems"
+task :push => :build do 
+  sh "gem push pkg/#$gem_name-#{Rod::VERSION}.gem"
 end
 
 desc "Uninstall the library from local machnie"

data/changelog.txt

@@ -1,3 +1,16 @@
+0.6.2
+- #127 default implementation of inspect
+- #123 fix: warning on has_rdoc in gemspec
+- #116 missing tmp directory for a fresh project
+- Slightly complicate the append feature
+- #120 fix: removal of database so file
+- #119 fix: segfault when accessing fresh object's properties
+- Some clean-up of gemspec
+- #118 fix: ISO C90 forbids mixed declarations and code
+- Fix gemspec - only year-moth-day is preserved
+- Update cuke to 1.0 & change README to rdoc
+- #115 fix: UINT -> ULONG
+- #114 fix: encoding of marshalled values
 0.6.1
 - Change order of tests in all_tests
 - Update DB 'created_at' if empty

data/contributors.txt

@@ -0,0 +1,2 @@
+People who contributed to Ruby Object Database:
+* qadro

data/features/append.feature

@@ -0,0 +1,221 @@
+Feature: database with append 
+  The database should allow storage of new objects after the database
+  was created and closed.
+
+  Background:
+    Given the library works in development mode
+
+  Scenario: simple append
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string
+    When database is created
+    And I create a User
+    And his name is 'Fred'
+    And I store him in the database 1000 times
+    And I reopen database
+    And I store him in the database 1000 times
+    And I reopen database
+    Then there should be 2000 User(s)
+
+  Scenario: append with indexing
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with flat index
+    And a class User has a surname field of type string with flat index
+    And a class User has a login field of type string
+    And a class User has an age field of type integer
+    When database is created
+    And I create and store the following User(s):
+      | name | surname | login | age  |
+      | John | Smith   | john  | 12   |
+      | Lara | Croft   | lara  | 23   |
+      | Adam | Parker  | adam  | 17   |
+    And I reopen database
+    And I create and store the following User(s):
+      | name | surname | login | age  |
+      | Mike | Spike   | mike  | 60   |
+      | Lara | Cook    | larac | 61   |
+      | Adam | Smith   | adams | 17   |
+    And I reopen database
+    Then there should be 6 User(s)
+    And there should be 1 User with 'Mike' name
+    And there should be 1 User with 'John' name
+    And there should be 2 User(s) with 'Lara' name
+    And there should be 2 User(s) with 'Adam' name
+
+    And there should be 2 User(s) with 'Smith' surname
+    And there should be 1 User with 'Croft' surname
+    And there should be 1 User with 'Parker' surname
+    And there should be 1 User with 'Spike' surname
+    And there should be 1 User with 'Cook' surname
+
+  Scenario: append with has one
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    And a class Caveman has a name field of type string
+    And a class Caveman has one automobile
+    When the database is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobile is the first Automobile created
+    And I store him in the database
+    And I reopen database
+    And I create an Automobile
+    And its name is 'Modern car'
+    And I store it in the database
+    And I create a Caveman
+    And her name is 'Willma'
+    And her automobile is the second Automobile created
+    And I store her in the database
+    And I reopen database
+    Then there should be 2 Caveman(s)
+    And there should be 2 Automobile(s)
+    And the name of the first Caveman should be 'Fred'
+    And the name of the first Automobile should be 'Prehistoric car'
+    And the name of the second Caveman should be 'Willma'
+    And the name of the second Automobile should be 'Modern car'
+    And the automobile of the first Caveman should be equal to the first Automobile
+    And the automobile of the second Caveman should be equal to the second Automobile
+
+  Scenario: append with has many
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    And a class Caveman has a name field of type string
+    And a class Caveman has many automobiles
+    When the database is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create another Automobile
+    And its name is 'Modern car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobiles contain the first Automobile created
+    And his automobiles contain the second Automobile created
+    And I store him in the database
+    And I reopen database
+    And I create an Automobile
+    And its name is 'Super car'
+    And I store it in the database
+    And I create a Caveman
+    And her name is 'Willma'
+    And her automobiles contain the first Automobile created
+    And her automobiles contain the second Automobile created
+    And her automobiles contain the third Automobile created
+    And I store her in the database
+    And I reopen database for reading
+    Then there should be 2 Caveman(s)
+    And there should be 3 Automobile(s)
+    And the name of the first Caveman should be 'Fred'
+    And the name of the first Automobile should be 'Prehistoric car'
+    And the name of the second Automobile should be 'Modern car'
+    And the first Caveman should have 2 automobiles
+    And the first of automobiles of the first Caveman should be equal to the first Automobile
+    And the second of automobiles of the first Caveman should be equal to the second Automobile
+    And the name of the second Caveman should be 'Willma'
+    And the second Caveman should have 3 automobiles
+    And the first of automobiles of the second Caveman should be equal to the first Automobile
+    And the second of automobiles of the second Caveman should be equal to the second Automobile
+    And the third of automobiles of the second Caveman should be equal to the third Automobile
+
+  Scenario: append with a new class
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    When database is created
+    And I create an Automobile
+    And his name is 'Prehistoric car'
+    And I store him in the database
+    And I reopen database
+    Then there should be 1 Automobile
+
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    And a class Caveman has a name field of type string 
+    When I open database
+    And I create a Caveman
+    And his name is 'Fred'
+    And I store him in the database
+    Then there should be 1 Automobile
+    And the name of the first Automobile should be 'Prehistoric car'
+    And there should be 1 Caveman
+    And the name of the first Caveman should be 'Fred'
+
+  Scenario: append of has many associations with indexing
+      It should be possible to append elements to has many association.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    And a class Caveman has a name field of type string
+    And a class Caveman has many automobiles with flat index
+    When the database is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobiles contain the first Automobile created
+    And I store him in the database
+    And I reopen database
+    And I create an Automobile
+    And its name is 'Modern car'
+    And I store it in the database
+    And I fetch the first Caveman
+    And his automobiles contain the second Automobile created
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And there should be 2 Automobile(s)
+    And the name of the first Caveman should be 'Fred'
+    And the name of the first Automobile should be 'Prehistoric car'
+    And the name of the second Automobile should be 'Modern car'
+    And the first Caveman should have 2 automobiles
+    And the first of automobiles of the first Caveman should be equal to the first Automobile
+    And the second of automobiles of the first Caveman should be equal to the second Automobile
+    And there should be 1 Caveman with the first Automobile as automobiles
+    And there should be 1 Caveman with the second Automobile as automobiles
+
+  # Enable for #94
+  @ignore
+  Scenario: append of has many associations with indexing with an unstored object
+      Same as above, but with an object which is appended to the collection
+      while it is not yet stored in the DB.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Automobile has a name field of type string
+    And a class Caveman has a name field of type string
+    And a class Caveman has many automobiles with flat index
+    When the database is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobiles contain the first Automobile created
+    And I store him in the database
+    And I create an Automobile
+    And its name is 'Modern car'
+    And I fetch the first Caveman
+    And his automobiles contain the second Automobile created
+    And I store him in the database
+    And I fetch the second Automobile created
+    And I store it in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And there should be 2 Automobile(s)
+    And the name of the first Caveman should be 'Fred'
+    And the name of the first Automobile should be 'Prehistoric car'
+    And the name of the second Automobile should be 'Modern car'
+    And the first Caveman should have 2 automobiles
+    And the first of automobiles of the first Caveman should be equal to the first Automobile
+    And the second of automobiles of the first Caveman should be equal to the second Automobile
+    And there should be 1 Caveman with the first Automobile as automobiles
+    And there should be 1 Caveman with the second Automobile as automobiles

data/features/assoc_indexing.feature

@@ -0,0 +1,66 @@
+Feature: Access to objects with indexed associations
+  ROD allows for accessing objects via associations with indices.
+
+  Background:
+    Given the library works in development mode
+
+  Scenario: indexing of singular associations
+      It should be possible to index singular associations. This is
+      useful when there are two databases and the other references
+      objects from the first, but the first cannot directly reference
+      objects from the second. In such a case, the second DB can have
+      indices for the associations to speed-up object look-up.
+    Given the class space is cleared
+    And a class Caveman inherits from Rod::Model
+    And a class Caveman has a name field of type string
+    And a class Caveman is connected to Database1
+    And a class Automobile inherits from Rod::Model
+    And a class Automobile has a name field of type string
+    And a class Automobile is connected to Database2
+    And a class Caveman has one automobile with flat index
+    When the Database1 is created
+    And the Database2 is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobile is the first Automobile created
+    And I store him in the database
+    And I reopen Database1 for reading
+    And I reopen Database2 for reading
+    Then there should be 1 Caveman
+    And there should be 1 Automobile
+    And there should exist a Caveman with the first Automobile as automobile
+    And there should be 1 Caveman with the first Automobile as automobile
+
+  Scenario: indexing of plural associations
+    Given the class space is cleared
+    And a class Caveman inherits from Rod::Model
+    And a class Caveman has a name field of type string
+    And a class Caveman is connected to Database1
+    And a class Automobile inherits from Rod::Model
+    And a class Automobile has a name field of type string
+    And a class Automobile is connected to Database2
+    And a class Caveman has many automobiles with flat index
+    When the Database1 is created
+    And the Database2 is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create another Automobile
+    And its name is 'Modern car'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his automobiles contain the first Automobile created
+    And his automobiles contain the second Automobile created
+    And I store him in the database
+    And I reopen Database1 for reading
+    And I reopen Database2 for reading
+    Then there should be 1 Caveman
+    And there should be 2 Automobile(s)
+    And there should exist a Caveman with the first Automobile as automobiles
+    And there should exist a Caveman with the second Automobile as automobiles
+    And there should be 1 Caveman with the first Automobile as automobiles
+    And there should be 1 Caveman with the second Automobile as automobiles

data/features/basic.feature

@@ -0,0 +1,199 @@
+Feature: Store and load small amount of data from one class
+  In order to ensure basic functionality, ROD should
+  allow to store and load data for one simple class.
+  Background:
+    Given the library works in development mode
+
+  Scenario: class with one field
+      Rod should allow to store in the DB instances of a class with one field
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And the name of the first Caveman should be 'Fred'
+
+    When database is created
+    And I create a Caveman
+    And her name is 'Wilma'
+    And I store her in the database
+    And I create another Caveman
+    And his name is 'Barney'
+    And I store him in the database
+    Then there should be 2 Caveman(s)
+    And the name of the first Caveman should be 'Wilma'
+    And the name of the second Caveman should be 'Barney'
+    And the third Caveman should not exist
+
+  Scenario: class with every type of field
+      Rod should allow to store in the DB instances of a class
+      having fields of each type
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    And a class Caveman has an age field of type integer
+    And a class Caveman has an identifier field of type ulong
+    And a class Caveman has a height field of type float
+    And a class Caveman has a symbol field of type object
+    And a class Caveman has a empty_string field of type string
+    And a class Caveman has a empty_object field of type object
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And his age is '25'
+    And his identifier is '111122223333'
+    And his height is '1.86'
+    And his symbol is ':fred'
+    # nil is converted to an empty string, consider using object field
+    # if you wish to store nil for string fields
+    And his empty_string is nil
+    # The field is not set to nil, but we assume that not set fields of
+    # type object are nils.
+    #And his empty_object is nil
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And the name of the first Caveman should be 'Fred'
+    And the age of the first Caveman should be '25'
+    And the identifier of the first Caveman should be '111122223333'
+    And the height of the first Caveman should be '1.86'
+    And the symbol of the first Caveman should be ':fred'
+    And the empty_string of the first Caveman should be ''
+    And the empty_object of the first Caveman should be nil
+
+  Scenario: instance with string containing 0
+      Rod should allow to store in the DB string values
+      containing characters equal to 0 (not the number but value)
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred\0Fred'
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And the name of the first Caveman should be 'Fred\0Fred'
+
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred\0' multiplied 30000 times
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And the name of the first Caveman should be 'Fred\0' multiplied 30000 times
+
+  Scenario: reading fields while objects are created
+      Rod should allow to read values of initialized fields of instances, before and after
+      the instance is stored to the DB.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    And a class Caveman has an age field of type integer
+    And a class Caveman has an identifier field of type ulong
+    And a class Caveman has a height field of type float
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And his age is '25'
+    And his identifier is '111122223333'
+    And his height is '1.86'
+    Then his name should be 'Fred'
+    And his age should be '25'
+    And his identifier should be '111122223333'
+    And his height should be '1.86'
+
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And I store him in the database
+    And I remember the first Caveman
+    And I create another Caveman
+    And his name is 'Fred'
+    And I store him in the database 4000 times
+    Then the name of the remembered instance should be 'Fred'
+
+  Scenario: reading properties of fresh object
+      Rod should allow to read values of uninitialized fields of instances,
+      before the instance is stored to the DB.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Item has an name field of type string
+    And a class Caveman has a name field of type string
+    And a class Caveman has an age field of type integer
+    And a class Caveman has an identifier field of type ulong
+    And a class Caveman has a height field of type float
+    And a class Caveman has a symbol field of type object
+    And a class Caveman has one item
+    And a class Caveman has many items
+    When database is created
+    And I create a Caveman
+    And I fetch the first Caveman created
+    Then his name should be ''
+    And his age should be nil
+    And his identifier should be nil
+    And his height should be nil
+    And his symbol should be nil
+    And his item should be nil
+    And his items should be empty
+
+  Scenario: referential integrity and simple indexing
+      Rod should allow to access objects via simple indexing
+      (i.e. Model[index]).
+      It should also impose referential integrity for objects
+      which are accessed via their indices.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And I store him in the database
+    And I reopen database for reading
+    Then the first Caveman should be identical with the first Caveman
+    And the first Caveman should be equal with the instance
+
+  Scenario: model without instances
+      A model without instances should be treated fine.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string with flat index
+    When database is created
+    And I reopen database for reading
+    Then there should be 0 Caveman(s)
+
+  Scenario: model without instances with indexed field
+      A model without instances but with indexed field should be treated fine.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string with flat index
+    And a class Automobile has a name field of type string with flat index
+    When database is created
+    And I create a Caveman
+    And his name is 'Fred'
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And there should be 0 Automobile(s)
+
+  Scenario: ActiveRecord-style initialization
+      A new instance of a model should accept hash of key-value pairs,
+      used to initialize its fields.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    And a class Caveman has a surname field of type string
+    When database is created
+    And I create a Caveman with 'Fred' name and 'Flintstone' surname
+    And I store him in the database
+    Then there should be 1 Caveman
+    And his name should be 'Fred'
+    And his surname should be 'Flintstone'
+
+    When database is created
+    And I create a Caveman with 'Fred' name and 'Flintstone' age
+    Then Rod::RodException should be raised