DbMotion 0.0.6 → 0.1.0

data/lib/DbMotion.rb

@@ -8,3 +8,4 @@ Motion::Project::App.setup do |app|
   app.files = Dir.glob(File.join(File.dirname(__FILE__), 'DbMotion/**/*.rb')) | app.files
   app.frameworks += ['CoreData']
 end
+

data/lib/DbMotion/database.rb

@@ -1,90 +1,179 @@
 module DbMotion
-class Database
+  class Database
   
-  def self.run
-    @@db
-  end
+    def self.shared
+      @@db
+    end
   
-  def create_entry(_name)
-    NSEntityDescription.insertNewObjectForEntityForName(_name, inManagedObjectContext:@context)
-  end
+    def self.setSharedSession(_db)
+      @@db=_db
+    end
   
-  # Example: _sort=[NSSortDescriptor.alloc.initWithKey('name', ascending:true)] 
-  def find_entry(_name, _sort=[])
-    request = NSFetchRequest.alloc.init
-    request.entity = NSEntityDescription.entityForName(_name, inManagedObjectContext:@context)
-    request.sortDescriptors = _sort
-    error_ptr = Pointer.new(:object)
-    @context.executeFetchRequest(request, error:error_ptr)
-  end
+    def create_entry(_name)
+      NSEntityDescription.insertNewObjectForEntityForName(_name, inManagedObjectContext:@context)
+    end
+  
+    def get_obj_id_from_url(_url)
+      @context.persistentStoreCoordinator.managedObjectIDForURIRepresentation(url)
+    end
+  
+    def get_url_from_obj_id(_obj_id)
+      _obj_id.URIRepresentation
+    end
+  
+    def find_by_obj_id(_obj_id)
+      error_ptr = Pointer.new(:object)
+      @context.existingObjectWithID(_obj_id, error:error_ptr)
+    end
+  
+    # Example: _sort=[NSSortDescriptor.alloc.initWithKey('name', ascending:true)] 
+    def find_entry(_name, _sort=[])
+      request = NSFetchRequest.alloc.init
+      request.entity = NSEntityDescription.entityForName(_name, inManagedObjectContext:@context)
+      request.sortDescriptors = _sort
+      error_ptr = Pointer.new(:object)
+      @context.executeFetchRequest(request, error:error_ptr)
+    end
 
-  def delete_entry(_obj)
-    @context.deleteObject(_obj)
-  end
+    def delete_entry(_obj)
+      @context.deleteObject(_obj)
+    end
   
-  def save
-    error_ptr = Pointer.new(:object)
-    @context.save(error_ptr)
-  end
+    def save
+      error_ptr = Pointer.new(:object)
+      @context.save(error_ptr)
+    end
   
-  def open(_mom_file, _db_file)
-    @mom_file=_mom_file % "cur"
-    @mom_url = NSURL.fileURLWithPath("#{NSBundle.mainBundle.resourcePath}/#{@mom_file}")
-    @model=NSManagedObjectModel.alloc.initWithContentsOfURL(@mom_url)
-    @store = NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(@model)
-    @store_file = File.join(NSHomeDirectory(), 'Documents', _db_file)
-    @store_url  = NSURL.fileURLWithPath(@store_file)
-    unless compatible?
-      migrate(_mom_file)
-    end
-    @context = NSManagedObjectContext.alloc.init
-    @context.persistentStoreCoordinator = @store
-    error_ptr = Pointer.new(:object)
-    unless @store.addPersistentStoreWithType(NSSQLiteStoreType, configuration:nil, URL:@store_url, options:nil, error:error_ptr)
-      raise "Can't add persistent SQLite store: #{error_ptr[0].description}"
-    end
-    @@db=self
-    self
-  end
+    def open(_db_file, withModel: _model)
+      @model=_model.versions.last
+      @store = NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(@model)
+      @store_file = File.join(NSHomeDirectory(), 'Documents', _db_file)
+      @store_url  = NSURL.fileURLWithPath(@store_file)
+      unless compatible?
+        migrate(_model.versions)
+      end
+      @context = NSManagedObjectContext.alloc.init
+      @context.persistentStoreCoordinator = @store
+      error_ptr = Pointer.new(:object)
+      unless @store.addPersistentStoreWithType(NSSQLiteStoreType, configuration:nil, URL:@store_url, options:nil, error:error_ptr)
+        raise "Can't add persistent SQLite store: #{error_ptr[0].description}"
+      end
+      self
+    end
   
-  def compatible?
-    error_ptr = Pointer.new(:object)
-    metadata=NSPersistentStoreCoordinator.metadataForPersistentStoreOfType(NSSQLiteStoreType, URL:@store_url, error:error_ptr)
-    compatible=true
-    if metadata
-      compatible=@model.isConfiguration(nil, compatibleWithStoreMetadata:metadata)
+    def open(_db_file, withMOMFile: _mom_file)
+      @mom_file=_mom_file % "cur"
+      @mom_url = NSURL.fileURLWithPath("#{NSBundle.mainBundle.resourcePath}/#{@mom_file}")
+      @model=NSManagedObjectModel.alloc.initWithContentsOfURL(@mom_url)
+      @store = NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(@model)
+      @store_file = File.join(NSHomeDirectory(), 'Documents', _db_file)
+      @store_url  = NSURL.fileURLWithPath(@store_file)
+      unless compatible?
+        migrate_mom(_mom_file)
+      end
+      @context = NSManagedObjectContext.alloc.init
+      @context.persistentStoreCoordinator = @store
+      error_ptr = Pointer.new(:object)
+      unless @store.addPersistentStoreWithType(NSSQLiteStoreType, configuration:nil, URL:@store_url, options:nil, error:error_ptr)
+        raise "Can't add persistent SQLite store: #{error_ptr[0].description}"
+      end
+      self
     end
-    compatible
-  end
   
-  def migrate(_old_mom_files)
-    old_mom_files=_old_mom_files % '%03d'
-    error_ptr = Pointer.new(:object)
-    metadata=NSPersistentStoreCoordinator.metadataForPersistentStoreOfType(NSSQLiteStoreType, URL:@store_url, error:error_ptr)
-    return false unless metadata
-    0.upto(999) do |version|
-      old_mom_file=old_mom_files % version
-      p old_mom_file
-      old_mom_url = NSURL.fileURLWithPath("#{NSBundle.mainBundle.resourcePath}/#{old_mom_file}")
-      p old_mom_url
-      old_model=NSManagedObjectModel.alloc.initWithContentsOfURL(old_mom_url)
-      compatible=old_model.isConfiguration(nil, compatibleWithStoreMetadata:metadata)
-      next unless compatible
-      p "Found version #{version}"
-      migmgr=NSMigrationManager.alloc.initWithSourceModel(old_model, destinationModel:@model)
-      mapping_model = NSMappingModel.inferredMappingModelForSourceModel(old_model, destinationModel:@model, error:error_ptr)
+    def compatible?
+      error_ptr = Pointer.new(:object)
+      metadata=NSPersistentStoreCoordinator.metadataForPersistentStoreOfType(NSSQLiteStoreType, URL:@store_url, error:error_ptr)
+      compatible=true
+      if metadata
+        compatible=@model.isConfiguration(nil, compatibleWithStoreMetadata:metadata)
+      end
+      compatible
+    end
+  
+    def migrate_mom_model(_old_mom_url, _new_mom_url)
+      error_ptr = Pointer.new(:object)
+      new_model=NSManagedObjectModel.alloc.initWithContentsOfURL(_new_mom_url)
+      old_model=NSManagedObjectModel.alloc.initWithContentsOfURL(_old_mom_url)
+      migmgr=NSMigrationManager.alloc.initWithSourceModel(old_model, destinationModel:new_model)
+      mapping_model = NSMappingModel.inferredMappingModelForSourceModel(old_model, destinationModel:new_model, error:error_ptr)
       new_store_url = NSURL.fileURLWithPath(@store_url.path+".new")
-      p migmgr.migrateStoreFromURL(@store_url, type:NSSQLiteStoreType, options:nil,
+      ret=migmgr.migrateStoreFromURL(@store_url, type:NSSQLiteStoreType, options:nil,
                                 withMappingModel:mapping_model, toDestinationURL:new_store_url,
                                 destinationType:NSSQLiteStoreType, destinationOptions:nil,
                                 error:error_ptr)
+      NSLog "Migration result #{ret}."
       NSFileManager.defaultManager.removeItemAtPath(@store_url.path, error:error_ptr)
-      #-TODO: evtl. move statt loeschen
       NSFileManager.defaultManager.moveItemAtPath(new_store_url.path, toPath:@store_url.path, error:error_ptr)
-      break
     end
-  end
   
-end
+    def migrate_mom(_old_mom_files)
+      old_mom_files=_old_mom_files % '%03d'
+      error_ptr = Pointer.new(:object)
+      metadata=NSPersistentStoreCoordinator.metadataForPersistentStoreOfType(NSSQLiteStoreType, URL:@store_url, error:error_ptr)
+      return false unless metadata
+      db_version=-1
+      0.upto(999) do |version|
+        old_mom_file=old_mom_files % version
+        NSLog [:migrate, "old mom file", old_mom_file].inspect
+        old_mom_url = NSURL.fileURLWithPath("#{NSBundle.mainBundle.resourcePath}/#{old_mom_file}")
+        NSLog [:migrate, "old mom url", old_mom_url].inspect
+        old_model=NSManagedObjectModel.alloc.initWithContentsOfURL(old_mom_url)
+        compatible=old_model.isConfiguration(nil, compatibleWithStoreMetadata:metadata)
+        next unless compatible
+        db_version=version
+        NSLog "Found version #{version}"
+        break
+      end
+      db_version.upto(999) do |version|
+        old_mom_file=old_mom_files % version
+        old_mom_url = NSURL.fileURLWithPath("#{NSBundle.mainBundle.resourcePath}/#{old_mom_file}")
+        new_mom_file=old_mom_files % (version+1)
+        new_mom_file="#{NSBundle.mainBundle.resourcePath}/#{new_mom_file}"
+        last=false
+        unless NSFileManager.defaultManager.fileExistsAtPath(new_mom_file)
+          new_mom_file=_old_mom_files % "cur"
+          new_mom_file="#{NSBundle.mainBundle.resourcePath}/#{new_mom_file}"
+          last=true
+        end
+        NSLog [:migrate_from_to, old_mom_file, new_mom_file].inspect
+        migrate_mom_model(old_mom_url, NSURL.fileURLWithPath(new_mom_file))
+        break if last
+      end
+    end
+  
+    def migrate_model(_old_model, _new_model)
+      error_ptr = Pointer.new(:object)
+      migmgr=NSMigrationManager.alloc.initWithSourceModel(_old_model, destinationModel:_new_model)
+      mapping_model = NSMappingModel.inferredMappingModelForSourceModel(_old_model, destinationModel:_new_model, error:error_ptr)
+      new_store_url = NSURL.fileURLWithPath(@store_url.path+".new")
+      ret=migmgr.migrateStoreFromURL(@store_url, type:NSSQLiteStoreType, options:nil,
+                                withMappingModel:mapping_model, toDestinationURL:new_store_url,
+                                destinationType:NSSQLiteStoreType, destinationOptions:nil,
+                                error:error_ptr)
+      NSLog "Migration result #{ret}."
+      NSFileManager.defaultManager.removeItemAtPath(@store_url.path, error:error_ptr)
+      NSFileManager.defaultManager.moveItemAtPath(new_store_url.path, toPath:@store_url.path, error:error_ptr)
+    end
+  
+    def migrate(_models)
+      error_ptr = Pointer.new(:object)
+      metadata=NSPersistentStoreCoordinator.metadataForPersistentStoreOfType(NSSQLiteStoreType, URL:@store_url, error:error_ptr)
+      return false unless metadata
+      found=false
+      old_model=nil
+      _models.each do |model|
+        unless found
+          found=model.isConfiguration(nil, compatibleWithStoreMetadata:metadata)
+          if found
+            old_model=model
+            NSLog "Found version #{model}"
+          end
+        else
+          migrate_model(old_mode, model)
+        end
+      end
+    end
+  
+  end
 end
 

data/lib/DbMotion/model.rb

@@ -0,0 +1,128 @@
+module DbMotion
+  class Model
+    
+    def self.get_version(_version)
+      @@models["#{sprintf "%03d", _version}"]
+    end
+    
+    def self.versions
+      @@models.keys.sort.map do |v|
+        @@models[v]
+      end
+    end
+    
+    def self.version(_version, &block)
+      @@models||={}
+      e = Entities.new(&block)
+      model = NSManagedObjectModel.alloc.init
+      model.entities=e.entities.values
+      @@models["#{sprintf "%03d", _version}"]=model
+    end
+    
+  end
+  
+  class Entities
+    attr_reader :entities
+
+    def initialize(&block)
+      @entities = {}
+      block.call(self)
+    end
+    
+    def entity(_name, &block)
+      e = Entity.new(&block)
+      entity = NSEntityDescription.alloc.init
+      entity.name = _name
+      entity.managedObjectClassName = _name
+      entity.properties = e.attributes.map do |type, name|
+        property = NSAttributeDescription.alloc.init
+        property.name = name
+        property.attributeType = type
+        property.optional = true
+        property
+      end
+      @entities[_name]=entity
+    end
+    
+    def relation(_relation)
+      # Example "model1 <->> model2"
+      relation=_relation.split(/ /)
+      if relation.size!=3
+        puts "Unknown relation"
+        return
+      end
+      if (relation[1]=~/^<{1,2}\->{1,2}$/).nil?
+        puts "Unknown relation type"
+        return
+      end
+      model1_info=relation[0].split(/:/)
+      model2_info=relation[2].split(/:/)
+      unless @entities.has_key?(model1_info[0]) and @entities.has_key?(model2_info[0])
+        puts "Relation partner not found #{relation}"
+        return
+      end
+      
+      model1 = NSRelationshipDescription.alloc.init
+      model2 = NSRelationshipDescription.alloc.init
+      
+      model1.name                = model1_info[1]
+      model1.destinationEntity   = @entities[model2_info[0]]
+      model1.inverseRelationship = model2
+      model1.deleteRule          = NSNullifyDeleteRule
+      if relation[1]=~/>>$/
+        # ->>
+        model1.minCount            = 0
+        model1.maxCount            = -1
+      else
+        # ->
+        model1.minCount            = 1
+        model1.maxCount            = 1
+        model1.optional            = true
+      end
+      
+      model2.name                = model2_info[1]
+      model2.destinationEntity   = @entities[model1_info[0]]
+      model2.inverseRelationship = model1
+      model2.deleteRule          = NSNullifyDeleteRule
+      if relation[1]=~/^<</
+        # <<-
+        model2.minCount            = 0
+        model2.maxCount            = -1
+      else
+        # <-
+        model2.minCount            = 1
+        model2.maxCount            = 1
+        model2.optional            = true
+      end
+      
+      @entities[model1_info[0]].properties=@entities[model1_info[0]].properties+[model1]
+      @entities[model2_info[0]].properties=@entities[model2_info[0]].properties+[model2]
+    end
+    
+  end
+  
+  class Entity
+    attr_reader :attributes
+
+    MAPPING={
+      string:  NSStringAttributeType,
+      integer: NSInteger16AttributeType,
+      double:  NSDoubleAttributeType,
+      date:    NSDateAttributeType,
+      bindata: NSBinaryDataAttributeType
+    }
+
+    def initialize(&block)
+      @attributes = []
+      block.call(self)
+    end
+    
+    def method_missing(meth, *args, &block)
+      if MAPPING.has_key?(meth.to_sym)
+        @attributes << [MAPPING[meth.to_sym], args[0]]
+      else
+        puts "Key #{meth} not found"
+      end
+    end
+  end
+end

data/lib/DbMotion/version.rb

@@ -1,3 +1,3 @@
 module DbMotion
-  VERSION = "0.0.6" unless defined?(DbMotion::VERSION)
+  VERSION = "0.1.0" unless defined?(DbMotion::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: DbMotion
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-16 00:00:00.000000000 Z
+date: 2013-05-13 00:00:00.000000000 Z
 dependencies: []
 description: DbMotion a simple adaption of CoreData.
 email:
@@ -26,6 +26,7 @@ files:
 - README.md
 - lib/DbMotion.rb
 - lib/DbMotion/database.rb
+- lib/DbMotion/model.rb
 - lib/DbMotion/version.rb
 homepage: https://github.com/rheoli/DbMotion
 licenses: []