maglevrecord 0.0.3 → 0.1.1

data/lib/maglev_record/snapshot/snapshot.rb

@@ -0,0 +1,67 @@
+require "maglev_record/snapshot/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
+
+    def ==(other)
+          self.snapshot_class == other.snapshot_class \
+      and self.exists? == other.exists?
+    end
+
+    alias :eql? :==
+
+    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)
+      attr_readers != older.attr_readers
+    end
+
+    def attr_readers
+      @attr_readers
+    end
+
+    def class_name
+      @snapshot_class.name
+    end
+  end
+
+  class Snapshot
+
+    def for_class(cls)
+      ClassSnapshot.new(cls)
+    end
+
+    def initialize
+      @class_snapshots = Snapshotable.snapshotable_classes.map{ |cls|
+        for_class cls
+      }
+    end
+
+    def changes_since(older)
+      Change.new(older, self)
+    end
+
+    def class_snapshots
+      Array.new(@class_snapshots)
+    end
+
+  end
+end
+

data/lib/maglev_record/snapshot/snapshotable.rb

@@ -0,0 +1,58 @@
+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
+
+module MaglevRecord
+  module Snapshotable
+    def self.snapshotable_classes
+      classes = []
+      Object.constants.each { |constant|
+        begin
+          cls = Object.const_get constant
+        rescue Exception
+        else
+          classes << cls if cls.is_a? Class and cls.ancestors.include? self
+        end
+      }
+      classes
+    end
+
+    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
+        } + self.methods(false).map { |m|
+          self.method(m).source_location.first
+        }).uniq
+      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?
+        }
+        exists?
+      end
+    end
+  end
+end

data/lib/maglev_record/snapshot.rb

@@ -0,0 +1,5 @@
+require "maglev_record/snapshot/snapshotable"
+require "maglev_record/snapshot/change"
+require "maglev_record/snapshot/snapshot"
+
+

data/lib/maglev_record/tools/object_reference.rb

@@ -0,0 +1,189 @@
+
+
+class Object
+  #
+  # breadth first search for references from the given object to self
+  #
+  def reference_path_to(to_object, length, trace = false)
+    paths = [[to_object]]
+    traversed = IdentitySet.new
+    traversed.add(to_object)
+    start_size = 1 if trace
+    while not paths.empty? and paths.first.size <= length
+      references = paths[0][0].find_references_in_memory
+      # if we print here a SecurityError mey occur
+      references.each{ |reference| 
+        return [reference] + paths[0] if reference.equal?(self)
+        unless traversed.include?(reference) or paths.any?{ |path| reference.equal?(path)}
+          paths.push([reference] + paths[0])
+          traversed.add(reference)
+        end
+      }
+      if trace and start_size != paths[0].size
+        puts "reference_path_length: #{paths[0].size}"
+        start_size = paths[0].size
+      end
+      paths.delete_at(0)
+    end
+    return nil
+  end
+  
+  def __hash_key_value
+    begin
+      assoc_value = instance_variable_defined?(:@_st_value)
+      assoc_key = instance_variable_defined?(:@_st_key)
+    rescue NameError
+      return nil
+    end
+    return nil unless assoc_key and assoc_value
+    return [assoc_key, assoc_value]
+  end
+
+  def __hash_key_value_equal_to(anObject)
+    value = __hash_key_value
+    return nil if value.nil?
+    assoc_key, assoc_value = value
+    return nil unless assoc_key.equal?(anObject) or assoc_value.equal?(anObject)
+    return [assoc_key, assoc_value]
+  end
+  
+  def __instance_variable_equal_to(anObject)
+    return nil unless self.respond_to?(:instance_variables) and self.respond_to?(:instance_variable_get)
+    self.instance_variables.each{ |v| 
+      return v if self.instance_variable_get(v).equal?(anObject)
+    }
+    return nil
+  end
+  
+  def __eigenclass_equal_to(anObject)
+    # breaks maglev if this is used by 
+    # maglev-ruby -e "require 'object_reference'; o = Object.new; start = Time.now; f = o.string_reference_path_to(true, 20); p start - Time.now; puts f"
+    return false if self.class.equal?(Array)
+    eigenclass = class << self
+      self
+    end
+    eigenclass.equal? anObject
+  end
+
+  def __incuded_module_equal_to(anObject)
+    included_modules.any?{ |m| m.equal?(anObject)} if respond_to? :included_modules
+  end
+
+  # format the reference path
+  #   returns a human readable string
+  #
+  #   length
+  #     the maximum length of the path
+  #
+  #   width_of_line
+  #     the maximum size of a line
+  #
+  #   trace
+  #     true if reference_path_length shall be printed to stdout to trace the progress
+  #     false otherwise
+  #
+  #   pretty
+  #     true if module includes shall be detected
+  #     false if maglev internals shall be revealed
+  #
+  def string_reference_path_to(to_object, length = 10, width_of_line = 80, trace = true, pretty = true)
+    reference_path = reference_path_to(to_object, length, trace)
+    return "" if reference_path.nil?
+    lines = []
+    left_column_size = 0
+    referenced_index = 0
+    while referenced_index < reference_path.size - 1
+      # prepare loop
+      object = reference_path[referenced_index]
+      referenced = reference_path[referenced_index + 1]
+      referenced_index += 1
+      name_of_referenced = '?? of'
+      inspect_string = nil
+      # switch case on displaying references
+      begin 
+        # puts "#obj: #{object.inspect}  #{referenced.inspect} at: #{referenced_index}\n\n"
+        # object --> class
+        if object.class.equal?(referenced)
+          name_of_referenced = 'class of'
+        # class --> superclass
+        elsif object.respond_to? :superclass and object.superclass.equal?(referenced)
+          name_of_referenced = 'superclass of'
+        # included
+        elsif pretty and object.__incuded_module_equal_to(reference_path[referenced_index + 2])
+          name_of_referenced = 'included by'
+          referenced = reference_path[referenced_index + 2]
+          referenced_index += 2
+        # OrderPreservingHashAssociation --> ...
+        elsif not object.__hash_key_value_equal_to(referenced).nil?
+          assoc_key, assoc_value = object.__hash_key_value_equal_to(referenced)
+          if assoc_value.equal?(referenced)
+            name_of_referenced = 'value of'
+          elsif assoc_key.equal?(referenced)
+            name_of_referenced = 'key of'
+          end
+        # ... --> OrderPreservingHashAssociation
+        elsif not referenced.__hash_key_value.nil?
+          assoc_key, assoc_value = referenced.__hash_key_value
+          inspect_string = "#{assoc_key.inspect} => #{assoc_value.inspect}"
+          name_of_referenced = 'association in'
+        # ... --> attribute
+        elsif not (variable = object.__instance_variable_equal_to(referenced)).nil?
+          name_of_referenced = variable.to_s + ' in'
+        # [...] -> object at index
+        elsif object.respond_to?(:find_index) and (index = object.find_index{ |element| element.equal?(referenced)})
+          name_of_referenced = "at #{index.inspect} of"
+        # eigenclass
+        elsif object.__eigenclass_equal_to(referenced)
+          name_of_referenced = "eigenclass of"
+        elsif referenced.__eigenclass_equal_to(object)
+          name_of_referenced = "eigenbase of"
+        end
+      rescue Exception => e
+        name_of_referenced = 'error'
+        referenced = e
+      end
+      begin
+        inspect_string = referenced.inspect if inspect_string.nil?
+      rescue
+        inspect_string = 'can not inspect this object'
+      end
+      lines << [name_of_referenced, inspect_string]
+      left_column_size = name_of_referenced.size if name_of_referenced.size > left_column_size
+    end
+    width_of_line -= 8 # subtract additional characters like ' is ' ' of '
+    right_column_size = width_of_line - left_column_size
+    right_column_size = 10 if right_column_size < 0
+    s = ""
+    lines.reverse.each{ |line|
+      s += "#{line[1][0..right_column_size]} is \n#{line[0].rjust(left_column_size)} "
+    }
+    return s + "#{reference_path[0].inspect}"
+  end
+end
+
+# TestCases
+
+## Hash
+# maglev-ruby -e "require 'object_reference'; d = {a:'2', b: 34}; f = d.string_reference_path_to(d[:a], 3); puts f"
+
+## superclass
+# maglev-ruby -e "require 'object_reference'; class AA;end; class BB < AA;end; class CC < BB; end; class DD < CC; end; class EE < DD; end; puts EE.string_reference_path_to(AA, 5)"
+
+## instance var
+# maglev-ruby -e "require 'object_reference'; class AA; attr_accessor :x end; o = Object.new; aa = AA.new; aa.x = o; puts aa.string_reference_path_to(o, 3)"
+
+## class and instvar 
+# maglev-ruby -e "require 'object_reference'; class AA; attr_accessor :x end; class OO; end;o = OO.new; aa = AA.new; aa.x = o; bb = AA.new; bb.x = aa; cc = AA.new; cc.x = bb; puts cc.string_reference_path_to(OO, 5)"
+
+## Object.new references true
+# maglev-ruby -e "require 'object_reference'; o = Object.new; start = Time.now; f = o.string_reference_path_to(true, 20); p start - Time.now; puts f" 
+
+## Array
+# maglev-ruby -e "require 'object_reference'; a = b = []; 20.times{a = [a]}; start = Time.now; f = a.string_reference_path_to(b, 20); p start - Time.now; puts f"
+
+## Eigenclass (x is eigenclass of y)
+# maglev-ruby -e "require 'object_reference'; class X;end; x = class <<X;self;end; puts X.string_reference_path_to(x, 5)"
+
+## Eigenbase ( reverse of eigenclass)
+# maglev-ruby -e "require 'object_reference'; class X;end; x = class <<X;self;end; puts x.string_reference_path_to(X, 5)"
+

data/lib/maglev_record/tools/submodule_finder.rb

@@ -0,0 +1,42 @@
+class MaglevSupport::SubmoduleFinder
+  def submodules_for(*constants)
+    whole_set = Set.new
+    constants.each do |constant|
+      @referenced_modules = Set.new
+      reference(constant)
+      whole_set = whole_set.union(@referenced_modules.select do |mod|
+        mod.name.to_s.include?(constant.to_s)
+      end)
+    end
+    constants + whole_set.to_a.sort_by do |mod| mod.name end
+  end
+
+  def reference(constant)
+    return if @referenced_modules.include?(constant)
+    @referenced_modules.add(constant)
+
+    submodules = constant.constants.map do |const|
+      begin
+        constant.const_get(const)
+      rescue Exception => e; end
+    end.select do |mod|
+      # We only want constants which are classes or modules, e.g. no Fixnums, Strings, ...
+      [Module, Class].include?(mod.class)
+    end
+
+    submodules.each do |mod|
+      reference(mod)
+    end
+  end
+  private :reference
+end
+
+if __FILE__ == $0
+  # EXAMPLE USAGE
+  require "rubygems"
+  require "rake"
+  puts "Finding all submodules of Rake."
+  ref_finder = SubmoduleFinder.new
+  referenced_modules = ref_finder.submodules_for(Rake)
+  puts referenced_modules.to_a.map { |mod| mod.name }.sort.inspect
+end

data/lib/maglev_record/tools.rb

@@ -0,0 +1,2 @@
+require "maglev_record/tools/object_reference"
+require "maglev_record/tools/submodule_finder"

data/lib/maglev_record.rb

@@ -1,4 +1,60 @@
-require "rubygems"
-require "maglev_record/model_not_saved_or_reset"
-require "maglev_record/base"
-require "maglev_record/persistence"
+require "active_model"
+require "active_support"
+require "active_support/core_ext/class/attribute"
+require "maglev_record/maglev_support/maglev_support"
+require "maglev_record/tools"
+require "bundler/setup"
+require "maglev_record/maglev_support/concern"
+require "set"
+require "logger"
+
+if defined? MaglevRecord::VERSION
+  if defined? RootedBook
+    RootedBook.redo_include_and_extend
+  end
+  if defined? UnrootedBook
+    UnrootedBook.redo_include_and_extend
+  end
+  MaglevRecord::Migration.redo_include_and_extend
+else
+  puts "IT IS NOT DEFINED"
+  # require "maglev_record/tools"
+  require "maglev_record/maglev_record"
+
+  require "maglev_record/snapshot"
+  require "maglev_record/maglev_support/secure_password"
+  require "maglev_record/sensible"
+  require "maglev_record/rooted_enumerable"
+  require "maglev_record/enumerable"
+  require "maglev_record/errors"
+  require "maglev_record/integration"
+  require "maglev_record/persistence"
+  require "maglev_record/read_write"
+  require "maglev_record/rooted_persistence"
+  require "maglev_record/migration"
+  require "maglev_record/base"
+  require "maglev_record/rooted_base"
+
+  module MaglevRecord
+    ref_finder = MaglevSupport::SubmoduleFinder.new
+    referenced_modules = ref_finder.submodules_for(MaglevRecord, MaglevSupport, Set)
+    MAGLEV_RECORD_PROC = Proc.new do |superklass_module|
+      referenced_modules.include?(superklass_module)
+    end
+
+    Maglev.persistent do
+      class ::Module
+        def maglev_record_persistable
+          self.maglev_persistable(true, &MAGLEV_RECORD_PROC)
+        end
+      end
+    end
+
+    referenced_modules.each do |mod|
+      mod.maglev_record_persistable
+    end
+  end
+end
+
+ActiveModel::Errors.maglev_nil_references
+Maglev.commit_transaction

data/lib/tasks/database.rake

@@ -0,0 +1,38 @@
+require "maglev_record/migration"
+require "time"
+require "logger"
+require "fileutils"
+
+MIGRATION_FOLDER = "migrations"
+
+desc "transform the maglev database"
+namespace :migrate do
+
+  desc "set up the project for migrations"
+  task :setup do
+    # puts "PID: #{Process.pid} stone: #{Maglev::System.stone_name}"
+    FileUtils.mkpath(MIGRATION_FOLDER) unless File.directory?(MIGRATION_FOLDER)
+  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)
+  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}"
+  end
+end
+

data/maglevrecord.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path "lib/maglev_record/maglev_record"
+
+Gem::Specification.new do |s|
+  s.name         = 'maglevrecord'
+  s.version      = MaglevRecord::VERSION
+  s.date         = '2013-05-06'
+  s.summary      = "MagLev persistence with an ActiveRecord-like interface!"
+  s.description  = "Library for using to MagLev to persist your data in a Rails app."
+  s.authors      = ["Dimitri Korsch", "Kirstin Heidler", "Nicco Kunzmann", "Matthias Springer", "Stefan Bunk"]
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.email        = "bp2012h1@hpi.uni-potsdam.de"
+  s.homepage     = 'https://github.com/knub/maglevrecord'
+  s.require_path = 'lib'
+
+end

data/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/test/_test_object_reference.rb

@@ -0,0 +1,70 @@
+require "maglev_record"
+
+# use
+# bundle exec rake test TESTOPTS="-v" TEST=test/_test_object_reference.rb
+
+
+module Mod
+
+end
+
+class AA
+  include Mod
+  attr_accessor :x
+end
+class BB < AA
+end
+class CC < BB
+end
+class DD < CC
+end
+class EE < DD
+end
+class OO
+end
+class X
+end
+
+o = OO.new
+d = {a:'2', b: 34}
+aa = AA.new
+aa.x = o;
+bb = AA.new
+bb.x = aa
+cc = AA.new
+cc.x = bb
+a = b = []
+20.times{ a = [a] }
+x = class << X
+  self
+end
+
+def self.assert_equal(v1, v2)
+  raise "expected \n#{v1.inspect}\n == \n#{v2.inspect}" unless v1 == v2
+end
+
+puts 'test_hash'
+assert_equal d.string_reference_path_to(d[:a], 3), "\"2\" is \n      value of :a => \"2\" is \nassociation in {:a=>\"2\", :b=>34}"
+
+puts 'test_superclass'
+assert_equal EE.string_reference_path_to(AA, 5), "AA is \nsuperclass of BB is \nsuperclass of CC is \nsuperclass of DD is \nsuperclass of EE"
+
+puts 'test_instance_variable'
+assert_equal aa.string_reference_path_to(o, 3), "#{o.inspect} is \n@x in #{aa.inspect}"
+
+puts 'test_class_to_inst_var'
+assert_equal cc.string_reference_path_to(OO, 5), "OO is \nclass of #{o.inspect} is \n   @x in #{aa.inspect} is \n   @x in #{bb.inspect} is \n   @x in #{cc.inspect}"
+
+puts 'test_array'
+assert_equal a.string_reference_path_to(b, 20), "[] is \nat 0 of [[]] is \nat 0 of [[[]]] is \nat 0 of [[[[]]]] is \nat 0 of [[[[[]]]]] is \nat 0 of [[[[[[]]]]]] is \nat 0 of [[[[[[[]]]]]]] is \nat 0 of [[[[[[[[]]]]]]]] is \nat 0 of [[[[[[[[[]]]]]]]]] is \nat 0 of [[[[[[[[[[]]]]]]]]]] is \nat 0 of [[[[[[[[[[[]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]] is \nat 0 of [[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]"
+
+puts 'test_eigenclass'
+assert_equal X.string_reference_path_to(x, 5), "#{x.inspect} is \neigenclass of X"
+
+puts 'test_eigenclass_base'
+assert_equal x.string_reference_path_to(X, 5), "X is \neigenbase of #{x.inspect}"
+
+puts 'test_include'
+assert_equal AA.string_reference_path_to(Mod, 5), "Mod is \nincluded by AA"
+
+puts 'done!'

data/test/example_model.rb

@@ -1,19 +1,32 @@
-require "maglev_record"
-
 class Book
-  include MaglevRecord::Base
-
+  include MaglevRecord::ReadWrite
   attr_accessor :author, :title, :comments
-
-  validates :author, :presence => true
-  validates :title,  :presence => true,
-                     :length => { :minimum => 5 }
-
-  def to_s
-    title
+  def self.example_params
+    { :author => "Author", :title => "Title" }
+  end
+  def self.example
+    self.new(example_params)
   end
+end
 
-  def self.dummy
-    Book.new(:title => "Harry Potter and the Chamber of Secrets", :author => "Joanne K. Rowling")
+class RootedBook < Book
+  include MaglevRecord::RootedBase
+  def book
+    puts "I am a RootedBook"
   end
 end
+
+class UnrootedBook < Book
+  include MaglevRecord::Base
+end
+
+Book.maglev_record_persistable
+RootedBook.maglev_record_persistable
+UnrootedBook.maglev_record_persistable
+Maglev.commit_transaction
+
+class RootedBook
+  include ActiveModel::Validations
+  validates :author, :presence => true,
+                     :length => { :minimum => 4 }
+end

data/test/migration/dummy_migrations/migration_1.rb

@@ -0,0 +1,8 @@
+Migration.new(Time.utc(2013, 2, 1, 10, 0, 0, 0), "Creating a global variable $DUMMY") do
+  def up
+    $DUMMY = 1
+  end
+  def down
+    $DUMMY = nil
+  end
+end

data/test/migration/dummy_migrations/migration_2.rb

@@ -0,0 +1,8 @@
+Migration.new(Time.utc(2014, 2, 1, 10, 0, 0, 0), "Multiplying $DUMMY by 2") do
+  def up
+    $DUMMY *= 2
+  end
+  def down
+    $DUMMY /= 2
+  end
+end

data/test/migration/dummy_migrations/migration_3.rb

@@ -0,0 +1,8 @@
+Migration.new(Time.utc(2015, 2, 1, 10, 0, 0, 0), "Adding 1 to $DUMMY") do
+  def up
+    $DUMMY += 1
+  end
+  def down
+    $DUMMY -= 1
+  end
+end

data/test/migration/migrations/migration_1.rb

@@ -0,0 +1,12 @@
+Migration.new(Time.utc(2013, 2, 1, 10, 0, 0, 0), "Change book title") do
+  def up
+    RootedBook.each do |book|
+      book.title = "A new book title"
+    end
+  end
+  def down
+    RootedBook.each do |book|
+      book.title = "Back to old title"
+    end
+  end
+end

data/test/migration/migrations/migration_2.rb

@@ -0,0 +1,12 @@
+Migration.new(Time.utc(2014, 2, 1, 10, 0, 0, 0), "Change book title again") do
+  def up
+    RootedBook.each do |book|
+      book.title = "A even newer book title"
+    end
+  end
+  def down
+    RootedBook.each do |book|
+      book.title = "A new book title"
+    end
+  end
+end

data/test/migration/migrations/migration_3.rb

@@ -0,0 +1,12 @@
+Migration.new(Time.utc(2015, 2, 1, 10, 0, 0, 0), "Change book title to most recent one") do
+  def up
+    RootedBook.each do |book|
+      book.title = "The most recent book title"
+    end
+  end
+  def down
+    RootedBook.each do |book|
+      book.title = "A even newer book title"
+    end
+  end
+end