maglevrecord 0.1.1 → 0.1.2

data/lib/maglev_record/snapshot/class_change.rb

@@ -0,0 +1,66 @@
+module MaglevRecord
+
+  #
+  # Change of a class between two class snapshots
+  #
+  class ClassChange
+    def initialize(old, new)
+      @old = old
+      @new = new
+    end
+
+    def new_attributes
+      (@new.attributes - @old.attributes).sort
+    end
+
+    def removed_attributes
+      (@old.attributes - @new.attributes).sort
+    end
+
+    def class_name
+      @old.class_name
+    end
+
+    def changed_class
+      @old.snapshot_class
+    end
+
+    def migration_string_list
+      if removed_attributes.size == 1 and new_attributes.size == 1
+        from_attr = removed_attributes.first
+        to_attr = new_attributes.first
+        ["#{class_name}.rename_attribute(:#{from_attr}, :#{to_attr})"]
+      else
+        removed_attributes.map{ |attr|
+          "#{class_name}.delete_attribute(:#{attr})"
+        } + new_attributes.map{ |attr|
+          "#new accessor :#{attr} of #{class_name}"
+        }
+      end + new_class_methods.map{ |cm|
+          "#new class method: #{class_name}.#{cm.to_s}"
+        } + new_instance_methods.map{ |im|
+          "#new instance method: #{class_name}.new.#{im.to_s}"
+        } + removed_class_methods.map{ |cm|
+          "#{class_name}.remove_class_method :#{cm}"
+        } + removed_instance_methods.map{ |im|
+          "#{class_name}.remove_instance_method :#{im}"
+        }
+    end
+
+    def new_instance_methods
+      (@new.instance_methods - @old.instance_methods).sort
+    end
+
+    def removed_instance_methods
+      (@old.instance_methods - @new.instance_methods).sort
+    end
+
+    def new_class_methods
+      (@new.class_methods - @old.class_methods).sort
+    end
+
+    def removed_class_methods
+      (@old.class_methods - @new.class_methods).sort
+    end
+  end
+end

data/lib/maglev_record/snapshot/class_snapshot.rb

@@ -0,0 +1,63 @@
+require "maglev_record/snapshot/class_change.rb"
+
+module MaglevRecord
+
+  class ClassSnapshot
+    def initialize(cls)
+      cls.redo_include_and_extend
+      @snapshot_class = cls
+      @attributes = cls.snapshot_attributes if cls.respond_to? :snapshot_attributes
+      @files = cls.file_paths
+      @exists = cls.has_definitions?
+      @class_methods = cls.snapshot_class_methods
+      @instance_methods = cls.snapshot_instance_methods
+    end
+
+    def exists?
+      @exists
+    end
+
+    def ==(other)
+          self.snapshot_class == other.snapshot_class \
+      and self.exists? == other.exists?
+    end
+
+    alias :eql? :==
+
+    def <=>(other)
+      class_name <=> other.class_name
+    end
+
+    def snapshot_class
+      @snapshot_class
+    end
+
+    def changes_since(older)
+      return nil unless changed_since?(older)
+      ClassChange.new(older, self)
+    end
+
+    def changed_since?(older)
+      attributes != older.attributes or
+        instance_methods != older.instance_methods or
+        class_methods != older.class_methods
+    end
+
+    def attributes
+      Array.new(@attributes || []).sort.uniq
+    end
+
+    def class_name
+      @snapshot_class.name
+    end
+
+    def class_methods
+      Array.new(@class_methods)
+    end
+
+    def instance_methods
+      @instance_methods
+    end
+  end
+end
+

data/lib/maglev_record/snapshot/snapshot.rb

@@ -1,67 +1,73 @@
+require "maglev_record/snapshot/snapshotable"
+require "maglev_record/snapshot/class_snapshot"
 require "maglev_record/snapshot/change"
+require "maglev_record/snapshot/superclass_mismatch_change"
 
 module MaglevRecord
-  class ClassSnapshot
-    def initialize(cls)
-      @snapshot_class = cls
-      @attr_readers = cls.attr_readers
-      @files = cls.file_paths
-      @exists = cls.has_definitions?
-    end
 
-    def exists?
-      @exists
-    end
+  class Snapshot
 
-    def ==(other)
-          self.snapshot_class == other.snapshot_class \
-      and self.exists? == other.exists?
+    def for_class(cls)
+      ClassSnapshot.new(cls)
     end
 
-    alias :eql? :==
-
-    def snapshot_class
-      @snapshot_class
+    def initialize(classes = Snapshotable.snapshotable_classes)
+      @class_snapshots = classes.map{ |cls|
+        for_class cls
+      }
     end
 
     def changes_since(older)
-      return nil unless changed_since?(older)
-      ClassChange.new(older, self)
+      Change.new(older, self)
     end
 
-    def changed_since?(older)
-      attr_readers != older.attr_readers
+    def class_snapshots
+      Array.new(@class_snapshots)
     end
 
-    def attr_readers
-      @attr_readers
+    def snapshot_classes
+      class_snapshots.map(&:snapshot_class)
     end
 
-    def class_name
-      @snapshot_class.name
+    def class_names
+      class_snapshots.map(&:class_name).sort
     end
-  end
 
-  class Snapshot
-
-    def for_class(cls)
-      ClassSnapshot.new(cls)
+    def [](cls)
+      class_snapshots.each{ |snap|
+        return snap if snap.snapshot_class == cls
+      }
     end
 
-    def initialize
-      @class_snapshots = Snapshotable.snapshotable_classes.map{ |cls|
-        for_class cls
+    def self.with_files(file_paths = [], classes = Snapshotable.snapshotable_classes)
+      class_files = classes.map(&:file_paths).flatten.uniq
+      restore_state = classes.map(&:reset)
+      begin
+      (file_paths + class_files).uniq.each{ |file_path|
+        begin
+          Kernel.load file_path if File.exist? file_path
+        rescue TypeError => e
+          class_name = e.message[/superclass mismatch for( class)? (\S*)$/, 2]
+          raise e if class_name.nil? # TODO: test
+          raise e unless Object.const_defined? class_name # TODO: test
+          cls = Object.const_get class_name # TODO: rescue exceptions
+          return SuperclassMismatchChange.new(cls, file_path)
+        end
       }
+      else
+        return new
+      ensure
+        restore_state.map(&:call)
+      end
     end
 
-    def changes_since(older)
-      Change.new(older, self)
+    def new_with_files(file_paths = [])
+      self.class.with_files(file_paths)
     end
 
-    def class_snapshots
-      Array.new(@class_snapshots)
+    def changes_in_files(file_paths = [])
+      return new_with_files(file_paths).changes_since(self)
     end
-
   end
 end
 

data/lib/maglev_record/snapshot/snapshotable.rb

@@ -1,22 +1,9 @@
-Maglev.persistent do
-  class ::Class
-    def exist!
-      @exists = true
-    end
-
-    def start_existence_test!
-      @exists = false
-    end
-
-    def exists?
-      return true if @exists
-      false
-    end
-  end
-end
+require "maglev_record/maglev_support/concern"
 
 module MaglevRecord
   module Snapshotable
+    extend MaglevSupport::Concern
+
     def self.snapshotable_classes
       classes = []
       Object.constants.each { |constant|
@@ -32,10 +19,6 @@ module MaglevRecord
 
     module ClassMethods
 
-      def self.extended(base)
-        base.exist! if base.respond_to? :exist!
-      end
-
       def file_paths
         (self.instance_methods(false).map { |m|
           self.instance_method(m).source_location.first
@@ -45,13 +28,85 @@ module MaglevRecord
       end
 
       def has_definitions?
-        # TODO: maybe in a nested transaction?
-        start_existence_test!
-        file_paths.each{ |file_path|
-          Kernel.load file_path if File.file? file_path
-          return true if exists?
+        # In nested transaction this error occurs:
+        # Error 2101, objId i52279553 does not exist, during transaction boundary
+        fp = file_paths
+        without_methods do
+          fp.each{ |file_path|
+            Kernel.load file_path if File.file? file_path
+          }
+          return !file_paths.empty?
+        end
+      end
+
+      def without_methods
+        return unless block_given?
+        memento = reset
+        begin
+          yield
+        ensure
+          memento.call
+        end
+      end
+
+      def class_methods_not_to_snapshot
+        @class_methods_not_to_reset ||= []
+        # hackady hack!
+        # welcome to the big ball of mud and the 
+        # "I do not know what goes on after hours trying"-architecture
+        @class_methods_not_to_reset << "_validators"
+        @class_methods_not_to_reset << "_validators="
+        @class_methods_not_to_reset << "_validators?"
+        #@class_methods_not_to_reset << "method_missing"
+        @class_methods_not_to_reset << methods(false).select{|m| m.include? "callback" }
+        @class_methods_not_to_reset.flatten!
+        @class_methods_not_to_reset.map!(&:to_s)
+        @class_methods_not_to_reset.uniq!
+        @class_methods_not_to_reset
+      end
+
+      def snapshot_class_methods
+        methods(false) - class_methods_not_to_snapshot
+      end
+
+      def snapshot_instance_methods
+        instance_methods(false).reject{|m| m.include? 'callback' or m.include? 'valid'}
+      end
+
+      def class_methods_to_reset
+        snapshot_class_methods
+      end
+
+      def instance_methods_to_reset
+        snapshot_instance_methods
+      end
+
+      #
+      # resets the class to no methods
+      # returns a memento proc that can be called to restore the old state
+      #
+      def reset
+        _instance_methods = instance_methods_to_reset.map { |m|
+          meth = instance_method m
+          remove_method m
+          meth
+        }
+        _class_methods = class_methods_to_reset.map { |m|
+          meth = method m
+          singleton_class.remove_method m
+          meth
+        }
+        return Proc.new {
+          instance_methods_to_reset.each { |m| remove_method m }
+          class_methods_to_reset.each{ |m| singleton_class.remove_method m }
+          _instance_methods.each{|m|
+            define_method m.name, m
+          }
+          _class_methods.each{|m|
+            singleton_class.define_method m.name, m
+          }
+          self
         }
-        exists?
       end
     end
   end

data/lib/maglev_record/snapshot/superclass_mismatch_change.rb

@@ -0,0 +1,143 @@
+
+class ClassWithMismatchNotFound
+  def name
+    "<fill in the name of the new superclass here>"
+  end
+end
+
+module MaglevRecord
+  class SuperclassMismatchChangeBase
+    "new_class_names new_classes
+    removed_class_names removed_classes changed_classes changed_class_names
+    ".split.each do |name|
+      define_method(name){ [] }
+    end
+
+    def nothing_changed?
+      false
+    end
+
+    def superclass_mismatch_classes
+      [self]
+    end
+
+    def superclass_mismatch_class_names
+      superclass_mismatch_classes.map(&:class_name)
+    end
+
+    def changes_since(snapshot)
+      self
+    end
+
+  end
+
+  class SuperclassMismatchChange < SuperclassMismatchChangeBase
+    def initialize(cls, file_path)
+      @cls = cls
+      @file_path = file_path
+    end
+
+    def file_path
+      @file_path
+    end
+
+    def migration_string(identation = 0)
+      " " * identation + [
+        "# TypeError: superclass mismatch for #{class_name}",
+        "# in #{file_path}",
+        "#{class_name}.change_superclass_to #{new_superclass.name}"
+      ].join("\n" + " " * identation)
+    end
+
+    def determine_new_superclass
+      # 1. replace the actual class by a new one
+      # 2. inherit
+      # 3. get the superclass
+      # 4. restore the class
+      constant_name = mismatching_class.name
+      class_to_replace = nil # change the scope
+      Maglev.persistent do
+        begin
+          class_to_replace = Object.remove_const constant_name
+        rescue NameError
+          # negative path 1 TODO: test
+          return ClassWithMismatchNotFound.new
+        else
+          if class_to_replace != mismatching_class
+            # negative path 2 TODO: test
+            Object.const_set constant_name, class_to_replace
+            return ClassWithMismatchNotFound.new
+          end
+        end
+      end
+      begin
+        Kernel.load file_path
+        cls = Object.const_get constant_name
+        return cls.superclass
+      ensure
+        Object.const_set constant_name, class_to_replace
+      end
+    end
+
+    def new_superclass
+      @new_super_class = determine_new_superclass if @new_super_class.nil?
+      @new_super_class
+    end
+
+    # methods for the single change
+
+    def class_name
+      mismatching_class.name
+    end
+
+    def mismatching_class
+      @cls
+    end
+
+    # reverse
+
+    def reversed
+      ReversedSuperclassMismatchChange.new(self)
+    end
+  end
+
+  class ReversedSuperclassMismatchChange < SuperclassMismatchChangeBase
+    # TODO: test
+    def initialize(superclass_mismatch_change)
+      @superclass_mismatch_change = superclass_mismatch_change
+    end
+
+    def superclass_mismatch_change
+      @superclass_mismatch_change
+    end
+
+    def reversed
+      superclass_mismatch_change
+    end
+
+    def mismatching_class
+      superclass_mismatch_change.mismatching_class
+    end
+
+    def class_name
+      superclass_mismatch_change.mismatching_class
+    end
+
+    def file_path
+      superclass_mismatch_change.file_path
+    end
+
+    def old_superclass
+      mismatching_class.superclass
+    end
+
+    def migration_string(identation = 0)
+      " " * identation + [
+        "# TypeError: superclass mismatch for #{class_name}",
+        "# in #{file_path}",
+        "#{class_name}.change_superclass_to #{old_superclass.name}"
+      ].join("\n" + " " * identation)
+    end
+
+  end
+end

data/lib/maglev_record/snapshot.rb

@@ -1,5 +1,6 @@
 require "maglev_record/snapshot/snapshotable"
 require "maglev_record/snapshot/change"
+require "maglev_record/snapshot/class_change"
+require "maglev_record/snapshot/class_snapshot"
 require "maglev_record/snapshot/snapshot"
-
-
+require "maglev_record/snapshot/superclass_mismatch_change"

data/lib/maglev_record/validations.rb

@@ -0,0 +1,49 @@
+module MaglevRecord
+  module Validations
+    def self.included(base)
+      base.extend(self::ClassMethods) if self.constants.include? 'ClassMethods'
+    end
+
+    def method_missing(symbol, *args)
+      self.class.create_validations
+      if self.respond_to?(symbol)
+        send(symbol, *args)
+      else
+        super
+      end
+    end
+
+    module ClassMethods
+
+      def method_missing(symbol, *args)
+        super unless symbol.to_s.include? "valid"
+
+        @validates_options ||= Hash.new
+        @validates_options[symbol] ||= []
+        @validates_options[symbol] << args
+      end
+
+      def create_validations
+        return if not self.maglev_persistable? or @validates_options.nil?
+
+        self.include MaglevSupport.constantize("ActiveModel::Validations")
+        @validates_options.each do |symbol, args_list|
+          args_list.each do |args|
+            self.send(symbol, *args)
+          end
+        end
+        @validates_options = nil
+      end
+
+      def reset
+        _validates_options = @validates_options
+        @validates_options = nil
+        reset_proc = super
+        return Proc.new {
+          reset_proc.call
+          @validates_options = _validates_options
+        }
+      end
+    end
+  end
+end

data/lib/maglev_record.rb

@@ -17,7 +17,6 @@ if defined? MaglevRecord::VERSION
   end
   MaglevRecord::Migration.redo_include_and_extend
 else
-  puts "IT IS NOT DEFINED"
   # require "maglev_record/tools"
   require "maglev_record/maglev_record"
 
@@ -29,6 +28,7 @@ else
   require "maglev_record/errors"
   require "maglev_record/integration"
   require "maglev_record/persistence"
+  require "maglev_record/validations"
   require "maglev_record/read_write"
   require "maglev_record/rooted_persistence"
   require "maglev_record/migration"
@@ -54,7 +54,8 @@ else
       mod.maglev_record_persistable
     end
   end
+  ActiveModel::Errors.maglev_nil_references
+  Maglev.commit_transaction
 end
 
 ActiveModel::Errors.maglev_nil_references
-Maglev.commit_transaction

data/lib/tasks/database.rake

@@ -1,9 +1,9 @@
-require "maglev_record/migration"
-require "time"
+require "maglev_record"
 require "logger"
 require "fileutils"
 
-MIGRATION_FOLDER = "migrations"
+MIGRATION_FOLDER = "./migrations"
+MODEL_FILES = Array.new(Dir.glob("./app/models/*.rb"))
 
 desc "transform the maglev database"
 namespace :migrate do
@@ -15,24 +15,68 @@ namespace :migrate do
   end
 
   desc "migrate all the migrations in the migration folder"
-  task :up => :setup do
-    loader = MaglevRecord::MigrationLoader.new
-    loader.load_directory(MIGRATION_FOLDER)
-    migrator = MaglevRecord::Migrator.new(loader.migration_list)
-    logger = Logger.new(STDOUT)
-    migrator.up(logger)
+  task :up => [:setup] do
+    migrator = MaglevRecord::Migrator.for_directory(MIGRATION_FOLDER)
+    migrator.up(Logger.new(STDOUT))
+    Rake::Task['migrate:load_all_models'].execute
+    Maglev::PERSISTENT_ROOT[:last_snapshot] = MaglevRecord::Snapshot.new
+    Maglev.commit_transaction
+  end
+
+  desc "show which migrations would be done by up"
+  task :up? => :setup do
+    # TODO: test
+    migrator = MaglevRecord::Migrator.for_directory(MIGRATION_FOLDER)
+    migrator.up?(Logger.new(STDOUT))
   end
 
   desc "create a new migration in the migration folder"
   task :new => :setup do
-    now = Time.now
-    filename = now.strftime("migration_%Y-%m-%b-%d_%H.%M.%S.rb")
-    content = MaglevRecord::Migration.file_content(now, 'fill in description here')
-    filepath = File.join(MIGRATION_FOLDER, filename)
-    File.open(filepath, 'w') { |file| 
-      file.write(content)
-    }
-    puts "created migration #{filepath}"
+    MaglevRecord::Migration.write_to_file(MIGRATION_FOLDER,
+                                          'fill in description here')
   end
+
+  desc "create a migration file for the changes shown by migrate:auto?"
+  task :auto => :setup do
+    last_snapshot = Maglev::PERSISTENT_ROOT[:last_snapshot]
+    if last_snapshot.nil?
+      puts "rake migrate:up has to be done first"
+      break
+    end
+    changes = last_snapshot.changes_in_files(MODEL_FILES)
+    if changes.nothing_changed?
+      puts "# no changes"
+      break
+    end
+    upcode = changes.migration_string(4)
+    downcode = changes.reversed.migration_string(4)
+    file_name = MaglevRecord::Migration.write_to_file(MIGRATION_FOLDER,
+                                          'fill in description here',
+                                          upcode,
+                                          downcode)
+    puts file_name
+  end
+
+  desc "show the changes since the last migrate:auto or migrate:up"
+  task :auto? do
+    last_snapshot = Maglev::PERSISTENT_ROOT[:last_snapshot]
+    if last_snapshot.nil?
+      puts "rake migrate:up has to be done first"
+      break
+    end
+    changes = last_snapshot.changes_in_files(MODEL_FILES)
+    if changes.nothing_changed?
+      puts "# no changes"
+    else
+      puts changes.migration_string
+    end
+  end
+
+  task :load_all_models do
+    MODEL_FILES.each do |model_file_path|
+      load model_file_path
+    end
+  end
+
 end