maglevrecord 0.0.3

data/lib/maglev_record/base.rb

@@ -0,0 +1,66 @@
+require "maglev_record/persistence"
+require "maglev_record/enumerable"
+require "maglev_record/read_write"
+require "rubygems"
+require "active_support"
+require "active_model"
+
+module MaglevRecord
+  module Base
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+
+    @attributes = {}
+    included do
+      include ActiveModel
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Conversion
+      include ActiveModel::Dirty
+      include ActiveModel::MassAssignmentSecurity
+      include ActiveModel::Validations
+      include MaglevRecord::Persistence
+      include MaglevRecord::Enumerable
+      include MaglevRecord::ReadWrite
+
+      self.maglev_persistable
+      ActiveSupport.maglev_persistable
+      ActiveSupport::HashWithIndifferentAccess.maglev_persistable
+    end
+
+    def initialize(*args)
+      if args.size == 1
+        args[0].each do |k, v|
+          self.send("#{k.to_s}=".to_sym, v)
+        end
+      end
+    end
+
+    def clear_dirty
+      @dirty = nil
+    end
+    def reset!
+      changed.each do |attr|
+        self.send "reset_#{attr}!".to_sym
+      end
+      clear_dirty
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    module ClassMethods
+      def create(*args)
+        x = self.new(*args)
+        x
+      end
+
+    end
+
+    def to_key
+      key = self.__id__
+      [key] if key
+    end
+
+  end
+end

data/lib/maglev_record/enumerable.rb

@@ -0,0 +1,35 @@
+require "active_support"
+
+module MaglevRecord
+  module Enumerable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      include ::Enumerable
+
+      def each
+        self.object_pool.each_value do |el|
+          yield(el)
+        end
+      end
+
+      def size
+        self.object_pool.size
+      end
+
+      alias_method :length, :size
+
+      def find_by_objectid(id)
+        self.object_pool[id]
+      end
+
+      def all
+        self.object_pool.values
+      end
+
+    end
+
+  end
+
+end
+

data/lib/maglev_record/model_not_saved_or_reset.rb

@@ -0,0 +1,15 @@
+# Maglev.persistent do
+#   Object.remove_const(:NotSavedOnReset)
+# end
+# Maglev.commit_transaction
+
+module MaglevRecord
+  Maglev.transient do
+    class ModelNotSavedOrReset
+      @instance = self.new
+      def self.new
+        @instance
+      end
+    end
+  end
+end

data/lib/maglev_record/persistence.rb

@@ -0,0 +1,66 @@
+require "active_support"
+
+module MaglevRecord
+  module Persistence
+    extend ActiveSupport::Concern
+
+    def delete
+      self.class.delete(self)
+    end
+
+    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"
+      end
+    end
+
+    def save(options = {})
+      begin
+        self.save!(options)
+      rescue StandardError
+        false
+      end
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def new_record?
+      !committed?
+    end
+
+    module ClassMethods
+      def object_pool
+        Maglev::PERSISTENT_ROOT[self.name.to_sym] ||= {}
+      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
+      end
+
+      def clear
+        self.object_pool.clear
+      end
+    end
+
+  end
+end
+

data/lib/maglev_record/read_write.rb

@@ -0,0 +1,41 @@
+require "active_support"
+
+module MaglevRecord
+  module ReadWrite
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def attr_reader(*attr_names)
+        attr_names.each do |attr_name|
+          define_attribute_method(attr_name)
+
+          generated_attribute_methods.module_eval <<-ATTRREADER, __FILE__, __LINE__ + 1
+            def #{attr_name}
+              attributes[:#{attr_name}]
+            end
+          ATTRREADER
+        end
+      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
+            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
+        end
+      end
+
+      def attr_accessor(*attr_names)
+        attr_reader *attr_names
+        attr_writer *attr_names
+      end
+    end
+  end
+end
+

data/lib/maglev_record.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "maglev_record/model_not_saved_or_reset"
+require "maglev_record/base"
+require "maglev_record/persistence"

data/test/example_model.rb

@@ -0,0 +1,19 @@
+require "maglev_record"
+
+class Book
+  include MaglevRecord::Base
+
+  attr_accessor :author, :title, :comments
+
+  validates :author, :presence => true
+  validates :title,  :presence => true,
+                     :length => { :minimum => 5 }
+
+  def to_s
+    title
+  end
+
+  def self.dummy
+    Book.new(:title => "Harry Potter and the Chamber of Secrets", :author => "Joanne K. Rowling")
+  end
+end

data/test/lint.rb

@@ -0,0 +1,110 @@
+module ActiveModel
+  module Lint
+    # == Active \Model \Lint \Tests
+    #
+    # You can test whether an object is compliant with the Active \Model API by
+    # including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
+    # include tests that tell you whether your object is fully compliant,
+    # or if not, which aspects of the API are not implemented.
+    #
+    # Note an object is not required to implement all APIs in order to work
+    # with Action Pack. This module only intends to provide guidance in case
+    # you want all features out of the box.
+    #
+    # These tests do not attempt to determine the semantic correctness of the
+    # returned values. For instance, you could implement <tt>valid?</tt> to
+    # always return true, and the tests would pass. It is up to you to ensure
+    # that the values are semantically meaningful.
+    #
+    # Objects you pass in are expected to return a compliant object from a call
+    # to <tt>to_model</tt>. It is perfectly fine for <tt>to_model</tt> to return
+    # +self+.
+    module Tests
+
+      # == Responds to <tt>to_key</tt>
+      #
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if <tt>model.persisted?</tt> is false. This is used by
+      # <tt>dom_id</tt> to generate unique ids for the object.
+      def test_to_key
+        assert model.respond_to?(:to_key), "The model should respond to to_key"
+        def model.persisted?() false end
+        assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
+      end
+
+      # == Responds to <tt>to_param</tt>
+      #
+      # Returns a string representing the object's key suitable for use in URLs
+      # or +nil+ if <tt>model.persisted?</tt> is +false+.
+      #
+      # Implementers can decide to either raise an exception or provide a
+      # default in case the record uses a composite primary key. There are no
+      # tests for this behavior in lint because it doesn't make sense to force
+      # any of the possible implementation strategies on the implementer.
+      # However, if the resource is not persisted?, then <tt>to_param</tt>
+      # should always return +nil+.
+      def test_to_param
+        assert model.respond_to?(:to_param), "The model should respond to to_param"
+        def model.to_key() [1] end
+        def model.persisted?() false end
+        assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
+      end
+
+      # == Responds to <tt>to_partial_path</tt>
+      #
+      # Returns a string giving a relative path. This is used for looking up
+      # partials. For example, a BlogPost model might return "blog_posts/blog_post"
+      def test_to_partial_path
+        assert model.respond_to?(:to_partial_path), "The model should respond to to_partial_path"
+        assert_kind_of String, model.to_partial_path
+      end
+
+      # == Responds to <tt>persisted?</tt>
+      #
+      # Returns a boolean that specifies whether the object has been persisted
+      # yet. This is used when calculating the URL for an object. If the object
+      # is not persisted, a form for that object, for instance, will route to
+      # the create action. If it is persisted, a form for the object will routes
+      # to the update action.
+      def test_persisted?
+        assert model.respond_to?(:persisted?), "The model should respond to persisted?"
+        assert_boolean model.persisted?, "persisted?"
+      end
+
+      # == \Naming
+      #
+      # Model.model_name must return a string with some convenience methods:
+      # <tt>:human</tt>, <tt>:singular</tt> and <tt>:plural</tt>. Check
+      # ActiveModel::Naming for more information.
+      def test_model_naming
+        assert model.class.respond_to?(:model_name), "The model should respond to model_name"
+        model_name = model.class.model_name
+        assert model_name.respond_to?(:to_str)
+        assert model_name.human.respond_to?(:to_str)
+        assert model_name.singular.respond_to?(:to_str)
+        assert model_name.plural.respond_to?(:to_str)
+      end
+
+      # == \Errors Testing
+      #
+      # Returns an object that implements [](attribute) defined which returns an
+      # Array of Strings that are the errors for the attribute in question.
+      # If localization is used, the Strings should be localized for the current
+      # locale. If no error is present, this method should return an empty Array.
+      def test_errors_aref
+        assert model.respond_to?(:errors), "The model should respond to errors"
+        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+      end
+
+      private
+        def model
+          assert @model.respond_to?(:to_model), "The object should respond_to to_model"
+          @model.to_model
+        end
+
+        def assert_boolean(result, name)
+          assert result == true || result == false, "#{name} should be a boolean"
+        end
+    end
+  end
+end

data/test/test_active_model_like_interface.rb

@@ -0,0 +1,11 @@
+require "test/unit"
+require "maglev_record"
+require "example_model"
+
+class ActiveModelLikeInterfaceTest < Test::Unit::TestCase
+  include ActiveModel::Lint::Tests
+
+  def model
+    Book.dummy
+  end
+end

data/test/test_dirty_object.rb

@@ -0,0 +1,50 @@
+# Maglev.persistent do
+#   Object.remove_const(:NotSavedOnReset)
+# end
+# Maglev.commit_transaction
+
+# Maglev.transient do
+#   class ModelNotSavedOrReset
+#   end
+# end
+
+# Maglev::PERSISTENT_ROOT['tmp'] = NotSavedOnReset.new
+# Maglev.commit_transaction
+
+require 'rubygems'
+require 'test/unit'
+
+class DirtyObjectTest < Test::Unit::TestCase
+
+  def setup
+    Maglev.abort_transaction
+    @book = Book.dummy
+    @book.save
+    Maglev.commit_transaction
+  end
+
+  def test_no_save_or_reset_throws_error
+    @book.author = "Shakespeare"
+    assert_raise TransactionError do
+      Maglev.commit_transaction
+    end
+  end
+
+  def test_reset_throws_no_error
+    @book.author = "Shakespeare"
+    @book.reset!
+    assert_nothing_raised Exception do
+      Maglev.commit_transaction
+    end
+    assert_equal "Joanne K. Rowling", @book.author
+  end
+
+  def test_save_throws_no_error
+    @book.author = "Shakespeare"
+    @book.save
+    assert_nothing_raised Exception do
+      Maglev.commit_transaction
+    end
+    assert_equal @book.author, "Shakespeare"
+  end
+end

data/test/test_maglev_record_base.rb

@@ -0,0 +1,22 @@
+#require 'bacon'
+#require 'maglev_record'
+
+#class ExampleStudent
+#  include Maglev::Base
+#
+#  attr_accessible :name
+#
+#  def initialize(name)
+#    name = name
+#  end
+#end
+
+#describe 'ExampleStudent' do
+#  let(:student) { ExampleStudent.new('Ferdinand') }
+#
+#  it "should know its name" do
+#    subject.name.should equal('Ferdinand')
+#  end
+#
+#end
+

data/test/test_maglev_simple_persistance.rb

@@ -0,0 +1,45 @@
+require "test/unit"
+require "maglev_record"
+require "example_model"
+
+class MaglevSimplePersistanceTest < Test::Unit::TestCase
+
+  def run_with_new_transaction
+    Maglev.abort_transaction
+    yield
+    Maglev.commit_transaction
+  end
+
+  def test_model_is_persisted
+    run_with_new_transaction do
+      book = Book.new(:title => "The Magician's Guild", :author => "Trudi Canavan")
+      book.save
+    end
+
+    run_with_new_transaction do
+      assert_equal Book.find { |b| b.title == "The Magician's Guild"}.author, "Trudi Canavan"
+    end
+  end
+
+  def test_model_is_deleted
+    run_with_new_transaction do
+      book = Book.new(:title => "Harry Potter and the Philosopher's stone", :author => "Joanne K. Rowling")
+      book.save
+    end
+
+    run_with_new_transaction do
+      Book.find { |b| b.title == "Harry Potter and the Philosopher's stone"}.delete
+    end
+
+    run_with_new_transaction do
+      assert_nil Book.find { |b| b.title == "Harry Potter and the Philosopher's stone"}
+    end
+  end
+
+  def teardown
+    run_with_new_transaction do
+      Book.clear
+    end
+  end
+
+end

data/test/test_query_interface.rb

@@ -0,0 +1,50 @@
+require "test/unit"
+require "maglev_record"
+require "example_model"
+
+class QueryInterfaceTest < Test::Unit::TestCase
+
+  def setup
+    [
+      Book.new(:title => "Harry Potter and the Philosopher's stone", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Chamber of Secrets", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Prisoner of Azkaban", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Goblet of Fire", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Order of the Phoenix", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Half-blood Prince", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Deathly Hallows", :author => "Joanne K. Rowling"),
+      Book.new(:title => "The Magician's Guild", :author => "Trudi Canavan")
+    ].each do |book|
+      book.save
+    end
+  end
+
+  def teardown
+    Book.clear
+  end
+
+  def test_size_returns_correct_amount_of_books
+    assert_equal Book.size, 8
+  end
+
+  def test_clear_clears_the_database
+    assert Book.size > 0
+    Book.clear
+    assert Book.size == 0
+  end
+
+  def test_first_returns_the_first_book
+    assert Book.first.title.include? "Philosopher"
+  end
+
+  def test_normal_enumerable_methods_work
+    assert_equal 7, Book.count { |b| b.author == "Joanne K. Rowling" }
+  end
+
+  def test_work_on_real_objects
+    book = Book.first
+    book.author = "William Shakespeare"
+    assert_equal Book.first.author, "William Shakespeare"
+  end
+
+end

data/test/test_validation.rb

@@ -0,0 +1,81 @@
+require "test/unit"
+require "maglev_record"
+require "example_model"
+
+class ValidationTest < Test::Unit::TestCase
+
+  def setup
+    [
+      Book.new(:title => "Harry Potter and the Philosopher's stone", :author => "Joanne K. Rowling"),
+      Book.new(:title => "Harry Potter and the Chamber of Secrets", :author => "Joanne K. Rowling")
+    ].each do |book|
+      book.save
+    end
+  end
+
+  def teardown
+    Book.clear
+  end
+
+  def test_reset_single_attribute
+    book = Book.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
+    book.author = "J. R. R. Tolkien"
+    book.reset_author!
+    assert_equal book.author, "Joanne K. Rowling"
+  end
+
+  def test_reset_all_attributes
+    book = Book.find { |b| b.title == "Harry Potter and the Philosopher's stone" }
+    book.author = "J. R. R. Tolkien"
+    book.title = "The Lord of the Rings"
+    #book.reset!
+    #assert_equal book.author, "Joanne K. Rowling"
+    #assert_equal book.title, "Harry Potter and the Philosopher's stone"
+  end
+
+  def invalid_model
+    Book.new(:author => "J. R. R. Tolkien", :title => "LotR")
+  end
+
+  def test_validation_fails
+    book = invalid_model
+    assert !book.valid?
+    assert book.invalid?
+  end
+
+  def test_errors_not_empty
+    book = invalid_model
+    book.valid?
+    assert book.errors.count > 0
+  end
+
+  def test_validation_succeeds
+    book = Book.new(:author => "J. R. R. Tolkien", :title => "Harry Potter and the Philosopher's stone")
+    assert book.valid?
+    assert !book.invalid?
+  end
+
+  def test_save_excl_invalid_throws_error
+    book = invalid_model
+
+    @catch = false
+    begin
+      book.save!
+    rescue StandardError
+      @catch = true
+    end
+
+    assert @catch
+  end
+
+  def test_save_invalid_returns_false
+    book = invalid_model
+    assert !book.save
+  end
+
+  def test_save_skip_validation
+    book = invalid_model
+    assert book.save(:validate => false)
+  end
+end
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: maglevrecord
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Dimitri Korsch
+- Kirstin Heidler
+- Nicco Kunzmann
+- Matthias Springer
+- Stefan Bunk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-10 00:00:00.000000000 Z
+dependencies: []
+description: Library for using to MagLev to persist your data in a Rails app.
+email: bp2012h1@hpi.uni-potsdam.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/maglev_record/model_not_saved_or_reset.rb
+- lib/maglev_record/enumerable.rb
+- lib/maglev_record/read_write.rb
+- lib/maglev_record/persistence.rb
+- lib/maglev_record/base.rb
+- lib/maglev_record.rb
+- test/example_model.rb
+- test/test_validation.rb
+- test/test_maglev_simple_persistance.rb
+- test/test_maglev_record_base.rb
+- test/lint.rb
+- test/test_query_interface.rb
+- test/test_dirty_object.rb
+- test/test_active_model_like_interface.rb
+homepage: https://github.com/knub/maglevrecord
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: MagLev persistence with an ActiveRecord-like interface!
+test_files: []