rod 0.7.1 → 0.7.2

data/lib/rod/property/base.rb

@@ -0,0 +1,190 @@
+require 'rod/exception'
+require 'rod/constants'
+
+module Rod
+  module Property
+    # This class defines the properties which are used in Rod::Model.
+    # These might be:
+    # * fields
+    # * has_one associations
+    # * has_many associations
+    # It provides basic data concerning these properties, such as name,
+    # options, etc.
+    class Base
+      # The name of the property.
+      attr_reader :name
+
+      # The options of the property.
+      attr_reader :options
+
+      # Initializes the property associated with +klass+
+      # with its +name+ and +options+.
+      def initialize(klass,name,options)
+        check_class(klass)
+        @klass = klass
+        check_name(name)
+        @name = name
+        check_options(options)
+        @options = options.dup.freeze
+      end
+
+      # Checks the difference in options between this and the +other+
+      # property. The prefix of legacy module is removed from the
+      # values of the options.
+      def difference(other)
+        self_options = {}
+        self.options.each{|k,v| self_options[k] = v.to_s.sub(LEGACY_RE,"")}
+        other_options = {}
+        other.options.each{|k,v| other_options[k] = v.to_s.sub(LEGACY_RE,"")}
+        differences = {}
+        self_options.each do |option,value|
+          if other_options[option] != value
+            differences[option] = [value,other_options[option]]
+          end
+        end
+        other_options.each do |option,value|
+          if self_options[option] != value && !differences.has_key?(option)
+            differences[option] = [self_options[option],value]
+          end
+        end
+        differences
+      end
+
+      # Returns the index associated with the property.
+      def index
+        @index ||= Index::Base.create(path(@klass.database.path),@klass,@options)
+      end
+
+      # Returns true if the property has an index.
+      def has_index?
+        !@options[:index].nil?
+      end
+
+      # Get rid of the index that is associated with this property.
+      def reset_index
+        @index = nil
+      end
+
+      # Creates a copy of the property with a new +klass+.
+      def copy(klass)
+        self.class.new(klass,@name,@options)
+      end
+
+      # Defines finders (+find_by+ and +find_all_by+) for indexed property.
+      def define_finders
+        return unless has_index?
+        # optimization
+        name = @name.to_s
+        property = self
+        (class << @klass; self; end).class_eval do
+          # Find all objects with given +value+ of the +property+.
+          define_method("find_all_by_#{name}") do |value|
+            property.index[value]
+          end
+
+          # Find first object with given +value+ of the +property+.
+          define_method("find_by_#{name}") do |value|
+            property.index[value][0]
+          end
+        end
+      end
+
+      protected
+      # The name of the file or directory (for given +relative_path+), where
+      # the data of the property (e.g. index) is stored.
+      def path(relative_path)
+        "#{relative_path}#{@klass.model_path}_#{@name}"
+      end
+
+      # Checks if the property +name+ is valid.
+      def check_name(name)
+        if !name.is_a?(Symbol) || name.to_s.empty? || INVALID_NAMES.has_key?(name)
+          raise InvalidArgument.new(name,"property name")
+        end
+      end
+
+      # Checks if the +klass+ is valid class for the property.
+      def check_class(klass)
+        raise InvalidArgument.new(klass,"class") if klass.nil?
+      end
+
+      # Reads the value of a field +name+ of the C struct +struct_name+
+      # that corresponds to given Ruby object. The C +result_type+
+      # of the result has to be specified.
+      def field_reader(name,struct_name,result_type,builder)
+        str =<<-END
+        |#{result_type} _#{name}(unsigned long object_rod_id){
+	|  VALUE klass;
+	|  #{struct_name} * pointer;
+        |  uint64_t as_uint;
+        |  uint64_t result_swapped;
+        |
+        |  if(object_rod_id == 0){
+        |    rb_raise(rodException(), "Invalid object rod_id (0)");
+        |  }
+        |  klass = rb_funcall(self,rb_intern("class"),0);
+        |  pointer = (#{struct_name} *)
+        |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
+        |#ifdef __BYTE_ORDER
+        |#  if __BYTE_ORDER == __BIG_ENDIAN
+        |  // This code assumes that all values are 64 bit wide. This is not true
+        |  // on 32-bit systems but is addressed in #221
+        |  as_uint = (pointer + object_rod_id - 1)->#{name};
+        |  result_swapped = bswap_64(*((uint64_t *)((char *)&as_uint)));
+        |  return *(#{result_type} *)((char *)&result_swapped);
+        |#  else
+        |  return (pointer + object_rod_id - 1)->#{name};
+        |#  endif
+        |#else
+        |  return (pointer + object_rod_id - 1)->#{name};
+        |#endif
+        |}
+        END
+        builder.c(str.margin)
+      end
+
+      # Writes the value of a field +name+ of the C struct +struct_name+
+      # that corresponds to given Ruby object. The C +arg_type+
+      # of the argument has to be specified.
+      def field_writer(name,struct_name,arg_type,builder)
+        str =<<-END
+        |void _#{name}_equals(unsigned long object_rod_id,#{arg_type} value){
+        |  VALUE klass;
+        |  #{struct_name} * pointer;
+        |  uint64_t value_swapped;
+        |
+        |  if(object_rod_id == 0){
+        |    rb_raise(rodException(), "Invalid object rod_id (0)");
+        |  }
+        |  klass = rb_funcall(self,rb_intern("class"),0);
+        |  pointer = (#{struct_name} *)
+        |    NUM2ULONG(rb_funcall(klass,rb_intern("rod_pointer"),0));
+        |#ifdef __BYTE_ORDER
+        |#  if __BYTE_ORDER == __BIG_ENDIAN
+        |  // TODO #220 #221
+        |  value_swapped = bswap_64(*((uint64_t *)((char *)&value)));
+        |  (pointer + object_rod_id - 1)->#{name} = value_swapped;
+        |#  else
+        |  (pointer + object_rod_id - 1)->#{name} = value;
+        |#  endif
+        |#else
+        |  (pointer + object_rod_id - 1)->#{name} = value;
+        |#endif
+        |}
+        END
+        builder.c(str.margin)
+      end
+
+      # Returns the size of the C type.
+      def sizeof(type)
+        # TODO implement
+        0
+      end
+
+      # Returns the C type for given Rod type.
+      def c_type(type)
+        TYPE_MAPPING[type]
+      end
+    end
+  end
+end

data/lib/rod/property/field.rb

@@ -0,0 +1,258 @@
+require 'rod/property/base'
+require 'rod/constants'
+require 'json'
+
+module Rod
+  module Property
+    # This class defines the field property.
+    # A field has to define its +name+ and its +type+.
+    class Field < Base
+      # The type of the property.
+      attr_reader :type
+
+      # The valid types of fields.
+      VALID_TYPES = [:string, :integer, :float, :ulong, :object, :json]
+
+      # The fields with variable size.
+      VARIABLE_TYPES = [:string, :object, :json]
+
+      # The name of the field used to identify the objects.
+      IDENTIFIER = :rod_id
+
+      # Initialize the field associated with the +klass+ with +name+, +type+ and +options+.
+      # The type should be one of:
+      # * +:integer+
+      # * +:ulong+
+      # * +:float+
+      # * +:string+
+      # * +:object+ (value is marshaled durign storage, and unmarshaled during read)
+      # * +:json+ (value is dumped in JSON format during storage, and loaded during read.
+      #   Note: some Ruby types are not unified during conversion, e.g. String and Symbol)
+      # The valid options are:
+      # * +:index+ builds an index for the field and might be:
+      # ** +:flat+ simple hash index (+true+ works as well for backwards compatiblity)
+      # ** +:segmented+ index split for 1001 pieces for shorter load times (only
+      #   one piece is loaded on one look-up)
+      def initialize(klass,name,type,options={})
+        super(klass,name,options)
+        check_type(type)
+        @type = type
+      end
+
+      # Creates a copy of the field with a new +klass+.
+      def copy(klass)
+        self.class.new(klass,@name,@type,@options)
+      end
+
+      # Predicate indicating that this property is a field.
+      def field?
+        true
+      end
+
+      # Predicate indicating that this property is not an association.
+      def association?
+        false
+      end
+
+      # Returns the default value for given type of field.
+      def default_value
+        case @type
+        when :integer
+          0
+        when :ulong
+          0
+        when :float
+          0.0
+        when :string
+          ''
+        when :object, :json
+          nil
+        end
+      end
+
+      # Returns true if the field has a variable size.
+      def variable_size?
+        VARIABLE_TYPES.include?(@type)
+      end
+
+      # Dumps the +value+ of the field according to its type.
+      def dump(value)
+        case @type
+        when :object
+          Marshal.dump(value)
+        when :json
+          JSON.dump([value])
+        when :string
+          # TODO the encoding should be stored in the DB
+          # or configured globally
+          value.encode("utf-8")
+        when :ulong
+          raise InvalidArgument.new(value,"ulong") if value < 0
+          value
+        else
+          value
+        end
+      end
+
+      # Loads the +value+ of the field according to its type.
+      def load(value)
+        return value unless variable_size?
+        case @type
+        when :object
+          value.force_encoding("ascii-8bit")
+          value = Marshal.load(value) rescue nil
+        when :json
+          value.force_encoding("ascii-8bit")
+          value = JSON.load(value).first rescue nil
+        when :string
+          value.force_encoding("utf-8")
+        end
+        value
+      end
+
+      # Returns true if the field is used to identify the objects.
+      def identifier?
+        @name == IDENTIFIER
+      end
+
+      # Returns the metadata of the field in form of a hash.
+      def metadata
+        @options.merge({:type => @type})
+      end
+
+      # Converts the field to fields in a C struct.
+      def to_c_struct
+        unless variable_size?
+          str = <<-SUBEND
+          |#ifdef __BYTE_ORDER
+          |#  if __BYTE_ORDER == __BIG_ENDIAN
+          |  uint64_t #{@name};
+          |#  else
+          |  #{c_type(@type)} #{@name};
+          |#  endif
+          |#else
+          |  #{c_type(@type)} #{@name};
+          |#endif
+          SUBEND
+          str.margin
+        else
+          "  #{c_type(:ulong)} #{@name}_length;\n" +
+            "  #{c_type(:ulong)} #{@name}_offset;\n"
+        end
+      end
+
+      # Defines the accessor of the field's constituents
+      # (C struct field/fields that hold the field data).
+      def define_c_accessors(builder)
+        unless variable_size?
+          field_reader(@name,@klass.struct_name,c_type(@type),builder)
+          field_writer(@name,@klass.struct_name,c_type(@type),builder)
+        else
+          field_reader("#{@name}_length",@klass.struct_name,c_type(:ulong),builder)
+          field_reader("#{@name}_offset",@klass.struct_name,c_type(:ulong),builder)
+          field_writer("#{@name}_length",@klass.struct_name,c_type(:ulong),builder)
+          field_writer("#{@name}_offset",@klass.struct_name,c_type(:ulong),builder)
+        end
+      end
+
+      # Make the C accessors private.
+      def seal_c_accessors
+        unless variable_size?
+          @klass.send(:private,"_#{@name}")
+          @klass.send(:private,"_#{@name}=")
+        else
+          @klass.send(:private,"_#{@name}_length")
+          @klass.send(:private,"_#{@name}_length=")
+          @klass.send(:private,"_#{@name}_offset")
+          @klass.send(:private,"_#{@name}_offset=")
+        end
+      end
+
+      # Defines the getter of the Ruby class which corresponds to this field.
+      def define_getter
+        field = @name.to_s
+        unless variable_size?
+          @klass.send(:define_method,field) do
+            value = instance_variable_get("@#{field}")
+            if value.nil?
+              if self.new?
+                value = nil
+              else
+                value = send("_#{field}",@rod_id)
+              end
+              instance_variable_set("@#{field}",value)
+            end
+            value
+          end
+        else
+          is_object = @type != :string
+          type = @type
+          property = self
+          database = @klass.database
+          @klass.send(:define_method,field) do
+            value = instance_variable_get("@#{field}")
+            if value.nil? # first call
+              if self.new?
+                return (is_object ? nil : "")
+              else
+                length = send("_#{field}_length", @rod_id)
+                if length == 0
+                  return (is_object ? nil : "")
+                end
+                offset = send("_#{field}_offset", @rod_id)
+                read_options = {}
+                if is_object
+                  read_options[:skip_encoding] = true
+                end
+                value = database.read_string(length, offset)
+                value = property.load(value)
+                # caching Ruby representation
+                # don't use setter - avoid change tracking
+                instance_variable_set("@#{field}",value)
+              end
+            end
+            value
+          end
+        end
+      end
+
+      # Defines the settor of the Ruby class which corresponds to this field.
+      def define_setter
+        # optimization
+        field = @name.to_s
+        @klass.send(:define_method,"#{field}=") do |value|
+          old_value = send(field)
+          send("#{field}_will_change!") unless old_value == value
+          instance_variable_set("@#{field}",value)
+          value
+        end
+      end
+
+      # Returns the memory layout of the C struct fields that
+      # correspond to this field.
+      def layout
+        unless variable_size?
+          "#{@name}[value:#{sizeof(@type)}]"
+        else
+          "#{@name}[length:#{sizeof(:ulong)}+" +
+            "offset:#{sizeof(:ulong)}]"
+        end
+      end
+
+      protected
+      # Check if the property has a valid type.
+      # An exceptions is raised if the type is invalid.
+      def check_type(type)
+        unless VALID_TYPES.include?(type)
+          raise InvalidArgument.new(type,"field type")
+        end
+      end
+
+      # Check if the property has valid options.
+      # An exceptions is raised if they are not.
+      def check_options(options)
+        #TODO implement
+      end
+    end
+  end
+end

data/lib/rod/property/plural_association.rb

@@ -0,0 +1,145 @@
+require 'rod/property/base'
+
+module Rod
+  module Property
+    # This class defines the +has_many+ (plural association) property.
+    # A +has_many+ property has to define its +name+.
+    class PluralAssociation < Base
+      # Creates new plural association associated with +klass+
+      # with given +name+ and +options+.
+      def initialize(klass,name,options={})
+        super(klass,name,options)
+      end
+
+      # Predicate indicating that this property is a field.
+      def field?
+        false
+      end
+
+      # Predicate indicating that this property is an association.
+      def association?
+        true
+      end
+
+      # Predicate indicating that this property is not a singular association.
+      def singular?
+        false
+      end
+
+      # Predicate indicating that this property is a plural association.
+      def plural?
+        true
+      end
+
+      # Predicate indicating that this property is polymorphic.
+      def polymorphic?
+        @options[:polymorphic]
+      end
+
+      # Returns the metadata of the association in form of a hash.
+      def metadata
+        @options.dup
+      end
+
+      # Converts the association to fields in a C struct.
+      def to_c_struct
+        "  #{c_type(:ulong)} #{@name}_offset;\n" +
+          "  #{c_type(:ulong)} #{@name}_count;\n"
+      end
+
+      # Defines the accessor of the association's constituents
+      # (C struct field/fields that hold the association data).
+      def define_c_accessors(builder)
+        field_reader("#{@name}_count",@klass.struct_name,c_type(:ulong),builder)
+        field_reader("#{@name}_offset",@klass.struct_name,c_type(:ulong),builder)
+        field_writer("#{@name}_count",@klass.struct_name,c_type(:ulong),builder)
+        field_writer("#{@name}_offset",@klass.struct_name,c_type(:ulong),builder)
+      end
+
+      # Make the C accessors private.
+      def seal_c_accessors
+        @klass.private "_#{@name}_count"
+        @klass.private "_#{@name}_count="
+        @klass.private "_#{@name}_offset"
+        @klass.private "_#{@name}_offset="
+      end
+
+      # Make the C accessors private.
+      def seal_c_accessors
+        @klass.send(:private,"_#{@name}_count")
+        @klass.send(:private,"_#{@name}_count=")
+        @klass.send(:private,"_#{@name}_offset")
+        @klass.send(:private,"_#{@name}_offset=")
+      end
+
+      # Defines the getter of the Ruby class which corresponds to this association.
+      def define_getter
+        # optimization
+        name = @name.to_s
+        class_name =
+          if options[:class_name]
+            options[:class_name]
+          else
+            "#{@klass.scope_name}::#{::English::Inflect.singular(name).camelcase}"
+          end
+        klass = options[:polymorphic] ? nil : class_name.constantize
+        database = @klass.database
+        @klass.send(:define_method,"#{name}") do
+          proxy = instance_variable_get("@#{name}")
+          if proxy.nil?
+            if self.new?
+              count = 0
+              offset = 0
+            else
+              count = self.send("_#{name}_count",@rod_id)
+              offset = self.send("_#{name}_offset",@rod_id)
+            end
+            proxy = CollectionProxy.new(count,database,offset,klass)
+            instance_variable_set("@#{name}", proxy)
+          end
+          proxy
+        end
+        # count getter
+        @klass.send(:define_method,"#{name}_count") do
+          if (instance_variable_get("@#{name}") != nil)
+            return instance_variable_get("@#{name}").count
+          else
+            if self.new?
+              return 0
+            else
+              return send("_#{name}_count",@rod_id)
+            end
+          end
+        end
+      end
+
+      # Defines the settor of the Ruby class which corresponds to this association.
+      def define_setter
+        # optimization
+        name = @name.to_s
+        @klass.send(:define_method,"#{name}=") do |value|
+          proxy = send(name)
+          proxy.clear
+          value.each do |object|
+            proxy << object
+          end
+          proxy
+        end
+      end
+
+      # Returns the memory layout of the C struct fields that
+      # correspond to this association.
+      def layout
+        "#{@name}[offset:#{sizeof(:ulong)}+" +
+          "count:#{sizeof(:ulong)}]"
+      end
+
+      protected
+      # Check if the property has valid options.
+      # An exceptions is raised if they are not.
+      def check_options(options)
+        #TODO implement
+      end
+    end
+  end
+end