rod 0.6.1 → 0.6.2

data/features/steps/test_helper.rb

@@ -0,0 +1,5 @@
+$:.unshift "lib"
+require 'rod'
+module RodTest
+end
+

data/lib/rod/abstract_database.rb

@@ -52,7 +52,7 @@ module Rod
       if File.exist?(@path)
         remove_file("#{@path}database.yml")
       else
-        Dir.mkdir(@path)
+        FileUtils.mkdir_p(@path)
       end
       self.classes.each do |klass|
         klass.send(:build_structure)
@@ -68,6 +68,7 @@ module Rod
         next if special_class?(klass)
         remove_files_but(klass.inline_library)
       end
+      remove_files(self.inline_library)
       generate_c_code(@path, classes)
       remove_files_but(self.inline_library)
       @metadata = {}
@@ -104,6 +105,7 @@ module Rod
       elsif options[:migrate]
         create_legacy_classes
         FileUtils.cp(@path + DATABASE_FILE, @path + DATABASE_FILE + LEGACY_DATA_SUFFIX)
+        remove_files(self.inline_library)
       end
       self.classes.each do |klass|
         klass.send(:build_structure)
@@ -266,16 +268,26 @@ module Rod
     end
 
     # Returns the string of given +length+ starting at given +offset+.
-    def read_string(length, offset)
+    # Options:
+    # * +:skip_encoding+ - if set to +true+, the string is left as ASCII-8BIT
+    def read_string(length, offset,options={})
       # TODO the encoding should be stored in the DB
       # or configured globally
-      _read_string(length, offset, @handler).force_encoding("utf-8")
+      value = _read_string(length, offset, @handler)
+      if options[:skip_encoding]
+        value.force_encoding("ascii-8bit")
+      else
+        value.force_encoding("utf-8")
+      end
     end
 
     # Stores the string in the DB encoding it to utf-8.
-    def set_string(value)
+    # Options:
+    # * +:skip_encoding+ - if set to +true+, the string is not encoded
+    def set_string(value,options={})
       raise DatabaseError.new("Readonly database.") if readonly_data?
-      _set_string(value.encode("utf-8"),@handler)
+      value = value.encode("utf-8") unless options[:skip_encoding]
+      _set_string(value,@handler)
     end
 
     # Returns the number of objects for given +klass+.

data/lib/rod/constants.rb

@@ -1,5 +1,5 @@
 module Rod
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 
   # The name of file containing the data base.
   DATABASE_FILE = "database.yml"

data/lib/rod/database.rb

@@ -57,19 +57,19 @@ module Rod
     # exist.
     def open_class_file(klass)
       str =<<-END
-      |// create the file unless it exists
-      |if(model_p->#{klass.struct_name}_lib_file == -1){
-      |  char * path = malloc(sizeof(char) * (strlen(model_p->path) +
-      |    #{klass.path_for_data("").size} + 1));
-      |  strcpy(path,model_p->path);
-      |  strcat(path,"#{klass.path_for_data("")}");
-      |  model_p->#{klass.struct_name}_lib_file =
-      |    open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
-      |  if(model_p->#{klass.struct_name}_lib_file == -1) {
-      |    rb_raise(rodException(),"Could not open file for class #{klass} on path %s writing.",path);
+      |  // create the file unless it exists
+      |  if(model_p->#{klass.struct_name}_lib_file == -1){
+      |    char * path = malloc(sizeof(char) * (strlen(model_p->path) +
+      |      #{klass.path_for_data("").size} + 1));
+      |    strcpy(path,model_p->path);
+      |    strcat(path,"#{klass.path_for_data("")}");
+      |    model_p->#{klass.struct_name}_lib_file =
+      |      open(path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+      |    if(model_p->#{klass.struct_name}_lib_file == -1) {
+      |      rb_raise(rodException(),"Could not open file for class #{klass} on path %s writing.",path);
+      |    }
+      |    free(path);
       |  }
-      |  free(path);
-      |}
       END
       str.margin
     end
@@ -109,34 +109,36 @@ module Rod
       |
       |  // increase the pages count by 1
       |  model_p->#{klass.struct_name}_page_count += ALLOCATED_PAGES;
-      |
-      |  // open the file for writing
-      |  FILE * #{klass.struct_name}_file =
-      |    fdopen(model_p->#{klass.struct_name}_lib_file,"w+");
-      |  if(#{klass.struct_name}_file == NULL){
-      |    rb_raise(rodException(),"Could not open file for #{klass.struct_name}.");
-      |  }
-      |  // seek to the end
-      |  if(fseek(#{klass.struct_name}_file,0,SEEK_END) == -1){
-      |    rb_raise(rodException(),"Could not seek to end file for #{klass.struct_name}.");
-      |  }
-      |  // write empty data at the end
-      |  char* #{klass.struct_name}_empty_data = calloc(page_size() * ALLOCATED_PAGES,1);
-      |  if(write(model_p->#{klass.struct_name}_lib_file,#{klass.struct_name}_empty_data,
-      |    page_size() * ALLOCATED_PAGES) == -1){
-      |    rb_raise(rodException(),"Could not write to file for #{klass.struct_name}.");
-      |  }
-      |  // seek to the beginning
-      |  if(fseek(#{klass.struct_name}_file,0,SEEK_SET) == -1){
-      |    rb_raise(rodException(),"Could not seek to start file for #{klass.struct_name}.");
-      |  }
-      |  // mmap the extended file
-      |  model_p->#{klass.struct_name}_table = mmap(NULL,
-      |    model_p->#{klass.struct_name}_page_count * page_size(),
-      |    PROT_WRITE | PROT_READ, MAP_SHARED, model_p->#{klass.struct_name}_lib_file,0);
-      |  if(model_p->#{klass.struct_name}_table == MAP_FAILED){
-      |    perror(NULL);
-      |    rb_raise(rodException(),"Could not mmap segment for #{klass.struct_name}.");
+      |  {
+      |    // open the file for writing
+      |    char* #{klass.struct_name}_empty_data;
+      |    FILE * #{klass.struct_name}_file =
+      |      fdopen(model_p->#{klass.struct_name}_lib_file,"w+");
+      |    if(#{klass.struct_name}_file == NULL){
+      |      rb_raise(rodException(),"Could not open file for #{klass.struct_name}.");
+      |    }
+      |    // seek to the end
+      |    if(fseek(#{klass.struct_name}_file,0,SEEK_END) == -1){
+      |      rb_raise(rodException(),"Could not seek to end file for #{klass.struct_name}.");
+      |    }
+      |    // write empty data at the end
+      |    #{klass.struct_name}_empty_data = calloc(page_size() * ALLOCATED_PAGES,1);
+      |    if(write(model_p->#{klass.struct_name}_lib_file,#{klass.struct_name}_empty_data,
+      |      page_size() * ALLOCATED_PAGES) == -1){
+      |      rb_raise(rodException(),"Could not write to file for #{klass.struct_name}.");
+      |    }
+      |    // seek to the beginning
+      |    if(fseek(#{klass.struct_name}_file,0,SEEK_SET) == -1){
+      |      rb_raise(rodException(),"Could not seek to start file for #{klass.struct_name}.");
+      |    }
+      |    // mmap the extended file
+      |    model_p->#{klass.struct_name}_table = mmap(NULL,
+      |      model_p->#{klass.struct_name}_page_count * page_size(),
+      |      PROT_WRITE | PROT_READ, MAP_SHARED, model_p->#{klass.struct_name}_lib_file,0);
+      |    if(model_p->#{klass.struct_name}_table == MAP_FAILED){
+      |      perror(NULL);
+      |      rb_raise(rodException(),"Could not mmap segment for #{klass.struct_name}.");
+      |    }
       |  }
       |#{update_pointer(klass) unless special_class?(klass)}
       END
@@ -153,6 +155,19 @@ module Rod
     # Implementations of abstract methods
     #########################################################################
 
+    # Ruby inline generated shared library name.
+    def inline_library
+      unless defined?(@inline_library)
+        self.class.inline(:C) do |builder|
+          builder.c_singleton("void __unused_method_#{rand(1000)}(){}")
+
+          self.instance_variable_set("@inline_library",builder.so_name)
+        end
+      end
+      @inline_library
+    end
+
+
     # Generates the code C responsible for management of the database.
     def generate_c_code(path, classes)
       if !@code_generated || @@rod_development_mode
@@ -177,14 +192,7 @@ module Rod
           END
           builder.prefix(str.margin)
 
-          str =<<-END
-          |VALUE rodException(){
-          |  VALUE klass = rb_const_get(rb_cObject, rb_intern("Rod"));
-          |  klass = rb_const_get(klass, rb_intern("DatabaseError"));
-          |  return klass;
-          |}
-          END
-          builder.prefix(str.margin)
+          builder.prefix(self.class.rod_exception)
 
 
           #########################################
@@ -215,7 +223,7 @@ module Rod
           |VALUE _join_element_index(unsigned long element_offset, unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return UINT2NUM((model_p->_join_element_table + element_offset + element_index)->offset);
+          |  return ULONG2NUM((model_p->_join_element_table + element_offset + element_index)->offset);
           |}
           END
           builder.c(str.margin)
@@ -225,7 +233,7 @@ module Rod
           |  unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return UINT2NUM((model_p->_polymorphic_join_element_table +
+          |  return ULONG2NUM((model_p->_polymorphic_join_element_table +
           |    element_offset + element_index)->offset);
           |}
           END
@@ -236,7 +244,7 @@ module Rod
           |  unsigned long element_index, VALUE handler){
           |  #{model_struct} * model_p;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  return UINT2NUM((model_p->_polymorphic_join_element_table +
+          |  return ULONG2NUM((model_p->_polymorphic_join_element_table +
           |    element_offset + element_index)->class);
           |}
           END
@@ -247,12 +255,11 @@ module Rod
           |  unsigned long element_index, unsigned long offset,
           |  VALUE handler){
           |  #{model_struct} * model_p;
-          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  _join_element * element_p;
+          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  element_p = model_p->_join_element_table + element_offset + element_index;
           |  if(element_p->index != element_index){
-          |      VALUE eClass = rb_const_get(rb_cObject, rb_intern("Exception"));
-          |      rb_raise(eClass, "Join element indices are inconsistent: %lu %lu!",
+          |      rb_raise(rodException(), "Join element indices are inconsistent: %lu %lu!",
           |        element_index, element_p->index);
           |  }
           |  element_p->offset = offset;
@@ -265,12 +272,11 @@ module Rod
           |  unsigned long element_index, unsigned long offset, unsigned long class_id,
           |  VALUE handler){
           |  #{model_struct} * model_p;
-          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  _polymorphic_join_element * element_p;
+          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  element_p = model_p->_polymorphic_join_element_table + element_offset + element_index;
           |  if(element_p->index != element_index){
-          |      VALUE eClass = rb_const_get(rb_cObject, rb_intern("Exception"));
-          |      rb_raise(eClass, "Polymorphic join element indices are inconsistent: %lu %lu!",
+          |      rb_raise(rodException(), "Polymorphic join element indices are inconsistent: %lu %lu!",
           |        element_index, element_p->index);
           |  }
           |  element_p->offset = offset;
@@ -284,8 +290,9 @@ module Rod
           |  _join_element * element;
           |  unsigned long index;
           |  #{model_struct} * model_p;
+          |  unsigned long result;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  unsigned long result = model_p->_join_element_count;
+          |  result = model_p->_join_element_count;
           |  for(index = 0; index < size; index++){
           |    if((model_p->_join_element_count + 1) * sizeof(_join_element) >=
           |      page_size() * model_p->_join_element_page_count){
@@ -306,8 +313,9 @@ module Rod
           |  _polymorphic_join_element * element;
           |  unsigned long index;
           |  #{model_struct} * model_p;
+          |  unsigned long result;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  unsigned long result = model_p->_polymorphic_join_element_count;
+          |  result = model_p->_polymorphic_join_element_count;
           |  for(index = 0; index < size; index++){
           |    if((model_p->_polymorphic_join_element_count + 1) *
           |      sizeof(_polymorphic_join_element) >=
@@ -332,8 +340,9 @@ module Rod
           str =<<-END
           |VALUE _read_string(unsigned long length, unsigned long offset, VALUE handler){
           |  #{model_struct} * model_p;
+          |  char * str;
           |  Data_Get_Struct(handler,#{model_struct},model_p);
-          |  char * str = model_p->#{StringElement.struct_name}_table + offset;
+          |  str = model_p->#{StringElement.struct_name}_table + offset;
           |  return rb_str_new(str, length);
           |}
           END
@@ -344,10 +353,9 @@ module Rod
           |// The return value is a pair: length and offset.
           |VALUE _set_string(VALUE ruby_value, VALUE handler){
           |  #{model_struct} * model_p;
-          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  unsigned long length = RSTRING_LEN(ruby_value);
           |  char * value = RSTRING_PTR(ruby_value);
-          |  unsigned long string_offset, page_offset, current_page;
+          |  unsigned long string_offset, page_offset, current_page, sum;
           |  char * dest;
           |  // table:
           |  // - address of the first page
@@ -356,12 +364,17 @@ module Rod
           |  // count:
           |  // - total number of bytes
           |  long length_left = length;
+          |  // see the routine description above.
+          |  VALUE result;
+          |  // get the structure
+          |  Data_Get_Struct(handler,#{model_struct},model_p);
           |  // first free byte in current page
           |  string_offset = model_p->#{StringElement.struct_name}_count % page_size();
           |  page_offset = model_p->#{StringElement.struct_name}_count / page_size();
           |  current_page = page_offset;
           |  while(length_left > 0){
-          |    if(length_left + string_offset >= page_size()){
+          |    sum = ((unsigned long)length_left) + string_offset;
+          |    if(sum >= page_size()){
           |      \n#{mmap_class(StringElement)}
           |    }
           |    dest = model_p->#{StringElement.struct_name}_table +
@@ -378,9 +391,9 @@ module Rod
           |
           |  model_p->#{StringElement.struct_name}_count += length;
           |
-          |  VALUE result = rb_ary_new();
-          |  rb_ary_push(result, UINT2NUM(length));
-          |  rb_ary_push(result, UINT2NUM(string_offset + page_offset * page_size()));
+          |  result = rb_ary_new();
+          |  rb_ary_push(result, ULONG2NUM(length));
+          |  rb_ary_push(result, ULONG2NUM(string_offset + page_offset * page_size()));
           |  return result;
           |}
           END
@@ -410,12 +423,13 @@ module Rod
             |void _store_#{klass.struct_name}(VALUE object, VALUE handler){
             |
             |  #{model_struct} * model_p;
+            |  #{klass.struct_name} * struct_p;
             |  Data_Get_Struct(handler,#{model_struct},model_p);
             |  if((model_p->#{klass.struct_name}_count+1) * sizeof(#{klass.struct_name}) >=
             |    model_p->#{klass.struct_name}_page_count * page_size()){
             |     \n#{mmap_class(klass)}
             |  }
-            |  #{klass.struct_name} * struct_p = model_p->#{klass.struct_name}_table +
+            |  struct_p = model_p->#{klass.struct_name}_table +
             |    model_p->#{klass.struct_name}_count;
             |  //printf("struct assigned\\n");
             |  model_p->#{klass.struct_name}_count++;
@@ -423,7 +437,7 @@ module Rod
             |  //the number is incresed by 1, because 0 indicates that the
             |  //(referenced) object is nil
             |  struct_p->rod_id = model_p->#{klass.struct_name}_count;
-            |  rb_iv_set(object, \"@rod_id\",UINT2NUM(struct_p->rod_id));
+            |  rb_iv_set(object, \"@rod_id\",ULONG2NUM(struct_p->rod_id));
             |}
             END
             builder.c(str.margin)
@@ -435,6 +449,7 @@ module Rod
           str = <<-END
           |VALUE _init_handler(char * dir_path){
           |  #{model_struct} * model_p;
+          |  VALUE cClass;
           |  model_p = ALLOC(#{model_struct});
           |
           |  #{init_structs(classes)}
@@ -444,7 +459,7 @@ module Rod
           |  strcpy(model_p->path,dir_path);
           |
           |  //create the wrapping object
-          |  VALUE cClass = rb_define_class("#{model_struct_name(path).camelcase(true)}",
+          |  cClass = rb_define_class("#{model_struct_name(path).camelcase(true)}",
           |    rb_cObject);
           |  return Data_Wrap_Struct(cClass, 0, free, model_p);
           |}
@@ -569,11 +584,6 @@ module Rod
           # This has to be at the very end of builder definition!
           self.instance_variable_set("@inline_library",builder.so_name)
 
-          # Ruby inline generated shared library.
-          def self.inline_library
-            @inline_library
-          end
-
         end
         @code_generated = true
       end
@@ -602,5 +612,16 @@ module Rod
       END
       builder.c(str.margin)
     end
+
+    def self.rod_exception
+      str =<<-END
+      |VALUE rodException(){
+      |  VALUE klass = rb_const_get(rb_cObject, rb_intern("Rod"));
+      |  klass = rb_const_get(klass, rb_intern("DatabaseError"));
+      |  return klass;
+      |}
+      END
+      str.margin
+    end
   end
 end

data/lib/rod/join_element.rb

@@ -13,7 +13,9 @@ module Rod
     end
 
     def self.layout
-      '  printf("  offset: %lu, index: %lu\n",sizeof(unsigned long), sizeof(unsigned long));' + "\n"
+      '  printf("  offset: %lu, index: %lu\n",' +
+        '(unsigned long)sizeof(unsigned long), ' +
+        '(unsigned long)sizeof(unsigned long));' + "\n"
     end
 
     def self.struct_name
@@ -39,7 +41,9 @@ module Rod
 
     def self.layout
       '  printf("  offset: %lu, index: %lu, class: %lu\n",' +
-        'sizeof(unsigned long), sizeof(unsigned long), sizeof(unsigned long));' + "\n"
+        '(unsigned long)sizeof(unsigned long), ' +
+        '(unsigned long)sizeof(unsigned long), ' +
+        '(unsigned long)sizeof(unsigned long));' + "\n"
     end
   end
 end

data/lib/rod/model.rb

@@ -52,14 +52,19 @@ module Rod
       self.class == other.class && self.rod_id == other.rod_id
     end
 
-    # Default implementation of to_s.
-    def to_s
+    # Default implementation of +inspect+.
+    def inspect
       fields = self.class.fields.map{|n,o| "#{n}:#{self.send(n)}"}.join(",")
       singular = self.class.singular_associations.map{|n,o| "#{n}:#{self.send(n).class}"}.join(",")
       plural = self.class.plural_associations.map{|n,o| "#{n}:#{self.send(n).size}"}.join(",")
       "#{self.class}:<#{fields}><#{singular}><#{plural}>"
     end
 
+    # Default implementation of +to_s+.
+    def to_s
+      self.inspect
+    end
+
     # Returns the number of objects of this class stored in the
     # database.
     def self.count
@@ -228,7 +233,11 @@ module Rod
         else
           raise RodException.new("Unrecognised field type '#{self.class.fields[name][:type]}'!")
         end
-        length, offset = database.set_string(value)
+        options = {}
+        if self.class.fields[name][:type] == :object
+          options[:skip_encoding] = true
+        end
+        length, offset = database.set_string(value,options)
         send("_#{name}_length=",@rod_id,length)
         send("_#{name}_offset=",@rod_id,offset)
       else
@@ -726,20 +735,23 @@ module Rod
       result = <<-END
       |  \n#{self.fields.map do |field,options|
           unless string_field?(options[:type])
-            "|  printf(\"  size of '#{field}': %lu\\n\",sizeof(#{TYPE_MAPPING[options[:type]]}));"
+            "|  printf(\"  size of '#{field}': %lu\\n\"," +
+              "(unsigned long)sizeof(#{TYPE_MAPPING[options[:type]]}));"
           else
             <<-SUBEND
             |  printf("  string '#{field}' length: %lu offset: %lu page: %lu\\n",
-            |    sizeof(unsigned long), sizeof(unsigned long), sizeof(unsigned long));
+            |    (unsigned long)sizeof(unsigned long), (unsigned long)sizeof(unsigned long),
+            |    (unsigned long)sizeof(unsigned long));
             SUBEND
           end
         end.join("\n") }
         |  \n#{singular_associations.map do |name, options|
-          "  printf(\"  singular assoc '#{name}': %lu\\n\",sizeof(unsigned long));"
+          "  printf(\"  singular assoc '#{name}': %lu\\n\","+
+          "(unsigned long)sizeof(unsigned long));"
         end.join("\n|  ")}
         |  \n#{plural_associations.map do |name, options|
        "|  printf(\"  plural assoc '#{name}' offset: %lu, count %lu\\n\",\n"+
-       "|    sizeof(unsigned long),sizeof(unsigned long));"
+       "|    (unsigned long)sizeof(unsigned long),(unsigned long)sizeof(unsigned long));"
         end.join("\n|  \n")}
       END
       result.margin
@@ -749,6 +761,9 @@ module Rod
     def self.field_reader(name,result_type,builder)
       str =<<-END
       |#{result_type} _#{name}(unsigned long object_rod_id){
+      |  if(object_rod_id == 0){
+      |    rb_raise(rodException(), "Invalid object rod_id (0)");
+      |  }
       |  VALUE klass = rb_funcall(self,rb_intern("class"),0);
       |  #{struct_name} * pointer = (#{struct_name} *)
       |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
@@ -762,6 +777,9 @@ module Rod
     def self.field_writer(name,arg_type,builder)
       str =<<-END
       |void _#{name}_equals(unsigned long object_rod_id,#{arg_type} value){
+      |  if(object_rod_id == 0){
+      |    rb_raise(rodException(), "Invalid object rod_id (0)");
+      |  }
       |  VALUE klass = rb_funcall(self,rb_intern("class"),0);
       |  #{struct_name} * pointer = (#{struct_name} *)
       |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
@@ -786,6 +804,7 @@ module Rod
 
       inline(:C) do |builder|
         builder.prefix(typedef_struct)
+        builder.prefix(Database.rod_exception)
         if Database.development_mode
           # This method is created to force rebuild of the C code, since
           # it is rebuild on the basis of methods' signatures change.
@@ -883,7 +902,11 @@ module Rod
                   return (options[:type] == :object ? nil : "")
                 end
                 offset = send("_#{field}_offset", @rod_id)
-                value = database.read_string(length, offset)
+                read_options = {}
+                if options[:type] == :object
+                  read_options[:skip_encoding] = true
+                end
+                value = database.read_string(length, offset, options)
                 if options[:type] == :object
                   value = Marshal.load(value)
                 end
@@ -917,6 +940,7 @@ module Rod
         define_method(name) do
           value = instance_variable_get("@#{name}")
           if value.nil?
+            return nil if @rod_id == 0
             rod_id = send("_#{name}",@rod_id)
             # the indices are shifted by 1, to leave 0 for nil
             if rod_id == 0
@@ -973,7 +997,11 @@ module Rod
           if (instance_variable_get("@#{name}") != nil)
             return instance_variable_get("@#{name}").count
           else
-            return send("_#{name}_count",@rod_id)
+            if @rod_id == 0
+              return 0
+            else
+              return send("_#{name}_count",@rod_id)
+            end
           end
         end