maglevrecord 0.0.3 → 0.1.1

data/lib/maglev_record/maglev_support/secure_password.rb

@@ -0,0 +1,39 @@
+module MaglevRecord
+  module SecurePassword
+    module ClassMethods
+      def has_secure_password
+        attr_reader :password
+
+        # TODO: No validations so far
+        # validates_confirmation_of :password
+        # validates_presence_of     :password_digest
+
+        mark_sensible :password, :password_confirmation
+    
+        include InstanceMethodsOnActivation
+      end
+
+      def encrypt_password(raw_password)
+        Digest::SHA256.new.update(raw_password).to_s
+      end
+    end
+
+    module InstanceMethodsOnActivation
+      def authenticate(raw_password)
+        if password_digest == self.class.encrypt_password(raw_password)
+          self
+        else
+          false
+        end
+      end
+
+      def password=(raw_password)
+        require 'digest'
+        attributes[:password] = raw_password
+        unless raw_password.blank?
+          self.password_digest = self.class.encrypt_password(raw_password)
+        end
+      end
+    end
+  end
+end

data/lib/maglev_record/migration/loader.rb

@@ -0,0 +1,38 @@
+require "maglev_record/migration"
+
+##
+# Offers methods for reading migrations from strings, files and directories.
+# Migrations are sorted and dou
+# All read in migrations can be accessed after the reading.
+module MaglevRecord
+  class MigrationLoader
+
+    def initialize
+      @migration_list = []
+    end
+
+    def migration_list
+      # TODO
+      # Print a warning, if there are two or more migrations which are equal.
+      @migration_list.sort.uniq
+    end
+
+    def load_string(source, file = __FILE__)
+      migration = instance_eval source, file
+      # TODO: Check class of migration is really migration!
+      migration.source = source
+      @migration_list << migration
+    end
+
+    def load_file(file_path)
+      raise ArgumentError, "file #{file_path.inspect} not found" unless File.file?(file_path)
+      load_string(File.open(file_path).read, file_path)
+    end
+
+    def load_directory(directory_path)
+      Dir.foreach(directory_path) { |file_name|
+        load_file(directory_path + '/' + file_name) if file_name.end_with? '.rb'
+      }
+    end
+  end
+end

data/lib/maglev_record/migration/migration.rb

@@ -0,0 +1,142 @@
+require "time"
+
+Maglev.persistent do
+  class ::String
+    def escape_single_quotes
+      self.gsub(/[']/, '\\\\\'')
+    end
+  end
+end
+
+module MaglevRecord
+  ##
+  # This class represents a migration which transfers the data set from one
+  # state to another.
+  # Each migrations is identified by its name and its timestamp. Creating a new
+  # migration is as easy as:
+
+  #   Migration.new("2013-02-02 1, 10, 0, 0, 0), "Change book title") do
+  #     def up
+  #       Book.each do |book|
+  #         book.title = "A new book title"
+  #       end
+  #     end
+  #     def down
+  #       Book.each do |book|
+  #         book.title = "Back to old title"
+  #       end
+  #     end
+  #   end
+  # Furthermore, this class offers methods to actually do data migration.
+  class Migration
+    redo_include ::Comparable
+
+    attr_accessor :source, :logger
+    attr_reader :timestamp
+    attr_reader :name
+
+    def initialize(timestamp, name, &block)
+      @timestamp = timestamp
+      @name = name
+      @done = false
+      instance_eval &block unless block.nil?
+    end
+
+    def id
+      self.class.id_for(timestamp, name)
+    end
+
+    def hash
+      id.hash
+    end
+
+    def self.id_for(timestamp, name)
+      [timestamp.month, timestamp.day, timestamp.hour, timestamp.min, timestamp.sec].reduce(timestamp.year.to_s) do |sum, s|
+        sum + s.to_s.rjust(2, '0')
+      end + name.to_s
+    end
+
+    def to_s
+      self.class.name + "<\"#{timestamp.year}-#{timestamp.month.to_s.rjust(2, '0')}-#{timestamp.day.to_s.rjust(2, '0')} #{timestamp.hour.to_s.rjust(2, '0')}:#{timestamp.min.to_s.rjust(2, '0')}:#{timestamp.sec.to_s.rjust(2, '0')}\", \"#{name}\">"
+    end
+
+    def inspect
+      return source unless source.nil?
+      to_s
+    end
+
+    def self.new(timestamp, name)
+      timestamp = Time.parse(timestamp) if timestamp.kind_of? String
+      id = id_for(timestamp, name)
+      migration = super(timestamp, name)
+    end
+
+    def done?
+      @done
+    end
+
+    def do
+      up if respond_to?(:up) && !done?
+      @done = true
+    end
+
+    def undo
+      down if done?
+      @done = false
+    end
+
+    def down
+      raise IrreversibleMigration, "The migration has no down code specified. Do something about it man. Either give it up or write a down method into the migration definition."
+    end
+
+    def <=>(other)
+      compare = timestamp <=> other.timestamp
+      return compare if compare != 0
+      name <=> other.name
+    end
+
+    def rename_class(old_class, new_name)
+      old_class.migration_rename_to(new_name)
+    end
+
+    def delete_class(cls)
+      cls.migration_delete
+    end
+
+    def self.const_missing(name)
+      #logger.warn("class #{name} was not created but migration by migration #{self.id}") if logger
+      MigrationOperations::NullClass.new(name)
+    end
+
+    def self.file_content(time, description, upcode = nil,
+                                    downcode = nil)
+      timestamp = time.to_s
+      Time.parse(timestamp) # make sure there is no error in the string
+      upcode = "    # put your transformation code here" if upcode.nil?
+      if downcode.nil?
+        downcode = "    # put the code that reverses the code in up here \n" +
+                   "    # remove the next line that throws he error \n" +
+                   "    raise IrreversibleMigration, " +
+                                             "'The migration has no downcode'"
+      end
+      <<-eos
+require "maglev_record/migration"
+require "time"
+
+MaglevRecord::Migration.new(Time.parse('#{
+                          timestamp.escape_single_quotes}'), '#{
+                          description.escape_single_quotes}') do
+
+  def up
+#{upcode}
+  end
+
+  def down
+#{downcode}
+  end
+
+end
+      eos
+    end
+  end
+end

data/lib/maglev_record/migration/migrator.rb

@@ -0,0 +1,40 @@
+module MaglevRecord
+  ##
+  # Given a migration list (the desired applied migrations)
+  # this class migrates to these state.
+  # Therefore, it decides which migrations must be undone, and
+  # which must be done and leaves the stone in the desired state.
+  class Migrator
+
+    MIGRATION_KEY = :__migrations__
+
+    def initialize(migration_list)
+      @migration_list = migration_list
+      @non_displaying_logger = Logger.new(STDOUT)
+      @non_displaying_logger.level = Logger::FATAL
+    end
+
+    ##
+    # Returns all migrations currently in the stone in the correct order.
+    def migration_store
+      Maglev::PERSISTENT_ROOT[MIGRATION_KEY] ||= SortedSet.new
+    end
+
+    ##
+    # Applies the desired state of migrations.
+    def up(logger = @non_displaying_logger)
+      Maglev.abort_transaction
+      to_do = @migration_list.reject do |mig|
+       migration_store.include?(mig.id)
+      end
+      logger.info("Already applied all migrations.") if to_do.empty?
+      to_do.sort.each do |mig|
+        mig.logger = logger
+        logger.info("Doing '" + mig.name + "' from " + mig.timestamp.to_s)
+        mig.do
+        migration_store << mig.id
+      end
+      Maglev.commit_transaction
+    end
+  end
+end

data/lib/maglev_record/migration/operations.rb

@@ -0,0 +1,92 @@
+module MaglevRecord
+  module MigrationOperations
+    module ClassMethods
+
+      def rename_instance_variable(old_name, new_name)
+        each { |model|
+          value = model.instance_variable_get(old_name)
+          value = yield value if block_given?
+          model.remove_instance_variable old_name.to_s
+          model.instance_variable_set(new_name, value)
+        }
+      end
+
+      def rename_attribute(old_name, new_name)
+        attr_accessor new_name
+        each { |model|
+          value = model.attributes[old_name]
+          value = yield value if block_given?
+          model.attributes.delete old_name
+          model.attributes[new_name] = value
+        }
+      end
+
+      def delete_instance_variable(name)
+        each { |model|
+          value = model.instance_variable_get(name)
+          yield value if block_given?
+          model.remove_instance_variable name.to_s
+        }
+      end
+
+      def delete_attribute(name)
+        each { |model|
+          value = model.attributes.delete(name)
+          yield value if block_given?
+        }
+      end
+
+      def migration_rename_to(new_name)
+        old_name = name
+        old_class = self
+        nested_class = old_class.nesting_list[-2]
+        Maglev.persistent do
+          cls = nested_class.remove_const nesting_name_list[-1]
+        end
+        old_class.instance_eval "
+          def name
+            '#{(nesting_name_list[0...-1] + [new_name.to_s]).join('::')}'
+          end
+        "
+        nested_class.const_set new_name, old_class
+      end
+
+      def migration_delete
+        Maglev.persistent do
+          nesting_list[-2].remove_const(nesting_name_list[-1])
+        end
+        delete_object_pool
+      end
+
+      def nesting_name_list
+         self.name.split('::')
+      end
+
+      def nesting_list
+        names = nesting_name_list
+        list = [Object]
+        names.each { |name|
+          list << list[-1].const_get(name)
+        }
+        list
+      end
+    end
+    class NullClass
+      include ClassMethods
+      def initialize(name)
+        @name = name
+      end
+      def new(*args)
+        # TODO: test
+        raise "This class #{@name} has not been created"
+      end
+      def each
+      end
+      def migration_rename_to(new_name)
+      end
+      def migration_delete
+      end
+    end
+  end
+end
+

data/lib/maglev_record/migration.rb

@@ -0,0 +1,5 @@
+require "maglev_record/migration/migration"
+require "maglev_record/migration/loader"
+require "maglev_record/migration/migrator"
+require "maglev_record/migration/operations"
+

data/lib/maglev_record/persistence.rb

@@ -1,66 +1,41 @@
-require "active_support"
-
 module MaglevRecord
   module Persistence
-    extend ActiveSupport::Concern
-
-    def delete
-      self.class.delete(self)
-    end
+    extend MaglevSupport::Concern
 
-    def save!(options = {})
-      if options[:validate] == false or self.valid?
-        @previously_changed = changes
-        @changed_attributes.clear
-        self.instance_variable_set(:@errors, nil)
-        self.class.object_pool[self.object_id] = self
-        @dirty = nil
-        true
-      else
-        raise StandardError, "Model validation failed"
+    def initialize(*args)
+      if args.size == 1
+        args[0].each do |k, v|
+          meth_name = "#{k.to_s}=".to_sym 
+          self.send(meth_name, v) if self.respond_to? meth_name
+        end
       end
+      @created_at_timestamp = Time.now
     end
 
-    def save(options = {})
-      begin
-        self.save!(options)
-      rescue StandardError
-        false
-      end
+    def created_at
+      @created_at_timestamp
     end
-
-    def persisted?
-      !new_record?
+    def created_at=(timestamp)
+      @created_at_timestamp = timestamp
     end
 
+    alias :persisted? :committed?
     def new_record?
-      !committed?
+      !persisted?
     end
 
-    module ClassMethods
-      def object_pool
-        Maglev::PERSISTENT_ROOT[self.name.to_sym] ||= {}
-      end
+    def id
+      object_id
+    end
 
-      def delete(*args)
-        if block_given? and args.size == 0
-          self.all.each do |m|
-            self.object_pool.delete(m.object_id) if yield(m)
-          end
-        elsif !block_given? and args.size > 0
-          args.each do |m|
-            self.object_pool.delete(m.object_id)
-          end
-        else
-          raise ArgumentError, "only block or arguments allowed"
-        end
+    module ClassMethods
+      def clear
+        raise MaglevRecord::InvalidOperationError, "Do not use clear without including MaglevRecord::RootedBase."
       end
 
-      def clear
-        self.object_pool.clear
+      def create
+        raise MaglevRecord::InvalidOperationError, "Do not use create without including MaglevRecord::RootedBase."
       end
     end
-
   end
-end
-
+end

data/lib/maglev_record/raketasks.rb

@@ -0,0 +1,9 @@
+require 'maglev_record/migration'
+require 'rails'
+
+class Railtie < Rails::Railtie
+  railtie_name :maglev_record
+  rake_tasks do
+    load "tasks/database.rake"
+  end
+end

data/lib/maglev_record/read_write.rb

@@ -1,15 +1,25 @@
-require "active_support"
 
 module MaglevRecord
   module ReadWrite
-    extend ActiveSupport::Concern
+    extend MaglevSupport::Concern
+
+    def attributes
+      @maglev_attributes ||= Hash.new 
+    end
+
+    def update_attributes(attribute_hash)
+      attribute_hash.each_pair do |k,v|
+        attributes[k.to_sym] = v
+      end
+      self
+    end
 
     module ClassMethods
       def attr_reader(*attr_names)
+        @attr_readers ||= []
         attr_names.each do |attr_name|
-          define_attribute_method(attr_name)
-
-          generated_attribute_methods.module_eval <<-ATTRREADER, __FILE__, __LINE__ + 1
+          attr_readers << attr_name
+          self.module_eval <<-ATTRREADER, __FILE__, __LINE__ + 1
             def #{attr_name}
               attributes[:#{attr_name}]
             end
@@ -17,14 +27,14 @@ module MaglevRecord
         end
       end
 
+      def attr_readers
+        @attr_readers
+      end
+
       def attr_writer(*attr_names)
         attr_names.each do |attr_name|
-          define_attribute_method(attr_name)
-
-          generated_attribute_methods.module_eval <<-ATTRWRITER, __FILE__, __LINE__ + 1
+          self.module_eval <<-ATTRWRITER, __FILE__, __LINE__ + 1
             def #{attr_name}=(new_value)
-              @dirty = ModelNotSavedOrReset.new
-              #{attr_name}_will_change! unless new_value == attributes[:#{attr_name}]
               attributes[:#{attr_name}] = new_value
             end
           ATTRWRITER

data/lib/maglev_record/rooted_base.rb

@@ -0,0 +1,8 @@
+module MaglevRecord
+  module RootedBase
+    extend MaglevSupport::Concern
+    include MaglevRecord::Base
+    include MaglevRecord::RootedPersistence
+    include MaglevRecord::RootedEnumerable
+  end
+end

data/lib/maglev_record/rooted_enumerable.rb

@@ -0,0 +1,25 @@
+module MaglevRecord
+  module RootedEnumerable
+    module ClassMethods
+      def all
+        object_pool.values
+      end
+      def each
+        object_pool.each_value do |model|
+          yield model
+        end
+      end
+      def size
+        object_pool.size
+      end
+      def find_by_objectid(id)
+        if id.respond_to? :to_i
+          id = id.to_i 
+        else
+          raise "#{id} do not respond to :to_i!"
+        end
+        object_pool[id]
+      end
+    end
+  end
+end

data/lib/maglev_record/rooted_persistence.rb

@@ -0,0 +1,36 @@
+module MaglevRecord
+  module RootedPersistence
+    extend MaglevSupport::Concern
+
+    module ClassMethods
+      def object_pool_key
+        self
+      end
+
+      def object_pool
+        Maglev::PERSISTENT_ROOT[MaglevRecord::PERSISTENT_ROOT_KEY] ||= {}
+        Maglev::PERSISTENT_ROOT[MaglevRecord::PERSISTENT_ROOT_KEY][object_pool_key] ||= {}
+      end
+
+      def delete_object_pool
+        Maglev::PERSISTENT_ROOT[MaglevRecord::PERSISTENT_ROOT_KEY].delete(object_pool_key)
+      end
+
+      def new(*args)
+        instance = super(*args)
+        self.object_pool[instance.id] = instance
+        instance
+      end
+
+      def clear
+        self.object_pool.clear
+      end
+
+      def create(*args)
+        instance = new(*args)
+        MaglevRecord.save
+        instance
+      end
+    end
+  end
+end

data/lib/maglev_record/sensible.rb

@@ -0,0 +1,28 @@
+module MaglevRecord
+  module Sensible
+    def sensibles
+      self.class.sensibles
+    end
+
+    def clear_sensibles
+      sensibles.each do |attribute|  
+        send("#{attribute}=", nil)
+      end
+    end
+
+    module ClassMethods
+      def sensibles
+        @maglev_sensible_attributes ||= Array.new
+      end
+
+      def mark_sensible(*attr_names)
+        @maglev_sensible_attributes ||= Array.new unless attr_names.empty?
+        attr_names.each do |attribute| 
+          @maglev_sensible_attributes << attribute unless @maglev_sensible_attributes.include?(attribute)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/maglev_record/snapshot/change.rb

@@ -0,0 +1,53 @@
+
+module MaglevRecord
+
+  class ClassChange
+    def initialize(old, new)
+      @old = old
+      @new = new
+    end
+    def new_attr_accessors
+      @new.attr_readers - @old.attr_readers
+    end
+    def removed_attr_accessors
+      @old.attr_readers - @new.attr_readers
+    end
+  end
+ 
+  class Change
+
+    def initialize(old, new)
+      @old = old
+      @new = new
+    end
+
+    def changed_classes
+      changes = []
+      @new.class_snapshots.each{ |new|
+        @old.class_snapshots.each { |old|
+          if  old == new and
+              new.changed_since? old
+            changes << new.changes_since(old)
+          end
+        }
+      }
+      changes
+    end
+
+    def removed_classes
+      @new.class_snapshots.select{ |new|
+        not new.exists? and @old.class_snapshots.all?{ |old|
+          old != new
+        }
+      }
+    end
+
+    def new_classes
+      @new.class_snapshots.select{ |new|
+        new.exists? and @old.class_snapshots.all?{ |old|
+          old != new
+        }
+      }
+    end
+  end
+end