versioned 0.1.0

data/README.rdoc

@@ -0,0 +1,51 @@
+= versioned
+
+Simple versioning for MongoMapper
+
+= installation
+
+The versioned gem is hosted on gemcutter.org:
+
+* gem install versioned
+
+= usage
+
+    class Doc
+      include MongoMapper::Document
+      include Versioned
+      key :title, String
+    end
+
+    @doc = Doc.create(:title=>"v1")
+    @doc.title = "v2"
+    @doc.save
+
+    @doc.revert
+
+    puts @doc.title
+    => v1
+
+    @doc.title = "v3"
+    @doc.save
+    @doc.version
+    => 3
+
+    @doc.retrieve_version 2
+    puts @doc.title 
+    => "v2"
+
+    @doc = Doc.find(@doc.id)
+    @doc.title
+    => "v3"
+    @doc.version
+    => 3
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+ 
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |g|
+    g.name = 'versioned'
+    g.summary = %(Versioning for MongoMapper)
+    g.description = %(Versioning for MongoMapper)
+    g.email = 'signalstatic@gmail.com'
+    g.homepage = 'http://github.com/twoism/versioned'
+    g.authors = %w(twoism toastyapps jacqui)
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com'
+end
+ 
+Rake::TestTask.new do |t|
+  t.libs = %w(test)
+  t.pattern = 'test/**/*_test.rb'
+end
+ 
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/version.rb

@@ -0,0 +1,20 @@
+class Version
+  include MongoMapper::Document
+  include Comparable
+  
+  key :number, Integer
+  key :versioned_type, String
+  key :versioned_id, ObjectId
+  key :changes, Hash
+  timestamps!
+
+  belongs_to :versioned, :polymorphic => true
+  def changes
+    read_attribute(:changes)
+  end
+  alias_attribute :version, :number
+
+  def <=>(other)
+    number <=> other.number
+  end
+end

data/lib/versioned.rb

@@ -0,0 +1,163 @@
+require 'version'
+
+module Versioned
+  def self.included(base)
+    base.extend ClassMethods
+    base.class_eval do
+      versioned
+    end
+  end
+
+  module ClassMethods
+    def versioned(options = {})
+      class_inheritable_accessor :version_only_columns
+      self.version_only_columns = Array(options[:only]).map(&:to_s).uniq if options[:only]
+      class_inheritable_accessor :version_except_columns
+      self.version_except_columns = Array(options[:except]).map(&:to_s).uniq if options[:except]
+
+      many :versions, :as => :versioned, :order => 'number ASC', :dependent => :delete_all do
+        def between(from, to)
+          from_number, to_number = number_at(from), number_at(to)
+          return [] if from_number.nil? || to_number.nil?
+          condition = (from_number == to_number) ? to_number : Range.new(*[from_number, to_number].sort)
+          if condition.is_a?(Range)
+            conditions = {'$gte' => condition.first, '$lte' => condition.last}
+          else
+            conditions = condition
+          end
+          find(:all, 
+            :number => conditions,
+            :order => "number #{(from_number > to_number) ? 'DESC' : 'ASC'}"
+          )
+        end
+
+        def at(value)
+          case value
+            when Version then value
+            when Numeric then find_by_number(value.floor)
+            when Symbol then respond_to?(value) ? send(value) : nil
+            when Date, Time then last(:created_at => {'$lte' => value.to_time})
+          end
+        end
+
+        def number_at(value)
+          case value
+            when Version then value.number
+            when Numeric then value.floor
+            when Symbol, Date, Time then at(value).try(:number)
+          end
+        end
+      end
+
+      after_create :create_initial_version
+      after_update :create_initial_version, :if => :needs_initial_version?
+      after_update :create_version, :if => :needs_version?
+
+      include InstanceMethods
+      alias_method_chain :reload, :versions
+    end
+  end
+
+  module InstanceMethods
+    private
+      def versioned_columns
+        case
+          when version_only_columns then self.class.keys.keys & version_only_columns
+          when version_except_columns then self.class.keys.keys - version_except_columns
+          else self.class.keys.keys
+        end - %w(created_at created_on updated_at updated_on)
+      end
+
+      def needs_initial_version?
+        versions.empty?
+      end
+
+      def needs_version?
+        !(versioned_columns & changed).empty?
+      end
+
+      def reset_version(new_version = nil)
+        @last_version = nil if new_version.nil?
+        @version = new_version
+      end
+
+      def create_initial_version
+        versions.create(:changes => nil, :number => 1)
+      end
+
+      def create_version
+        versions << Version.create(:changes => changes.slice(*versioned_columns), :number => (last_version + 1))
+        reset_version
+      end
+
+    public
+      def version
+        @version ||= last_version
+      end
+
+      def last_version
+        @last_version ||= versions.inject(1){|max, version| version.number > max ? version.number : max} 
+      end
+
+      def reverted?
+        version != last_version
+      end
+
+      def reload_with_versions(*args)
+        reset_version
+        reload_without_versions(*args)
+      end
+
+      def changes_between(from, to)
+        from_number, to_number = versions.number_at(from), versions.number_at(to)
+        return {} if from_number == to_number
+        chain = versions.between(from_number, to_number)
+        return {} if chain.empty?
+
+        backward = chain.first > chain.last
+        backward ? chain.pop : chain.shift
+
+        chain.inject({}) do |changes, version|
+          version.changes.each do |attribute, change|
+            change.reverse! if backward
+            new_change = [changes.fetch(attribute, change).first, change.last]
+            changes.update(attribute => new_change)
+          end
+          changes
+        end
+      end
+      
+      def revert
+        revert_to self.version -1
+      end
+      
+      def retrieve_version n
+        versions.find_by_number(n).changes.each do |n,v|
+          self.send("#{n.to_sym}=",v.first)
+        end 
+      end
+      
+      def revert_to(value)
+        to_number = versions.number_at(value)
+        changes = changes_between(version, to_number)
+        return version if changes.empty?
+
+        changes.each do |attribute, change|
+          write_attribute(attribute, change.last)
+        end
+
+        reset_version(to_number)
+      end
+
+      def revert_to!(value)
+        revert_to(value)
+        reset_version if saved = save
+        saved
+      end
+
+      def latest_changes
+        return {} if version.nil? || version == 1
+        versions.at(version).changes
+      end
+  end
+end

data/test/between_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class BetweenTest < Test::Unit::TestCase
+  context 'The number of versions between' do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @version = @user.version
+      @valid = [@version, 0, 1_000_000, :first, :last, 1.day.since(@user.created_at), @user.versions.first]
+      @invalid = [nil, :bogus, 'bogus', Date.parse('0001-12-25')]
+    end
+
+    context 'the current version and the current version' do
+      should 'equal one' do
+        assert_equal 1, @user.versions.between(@version, @version).size
+      end
+    end
+
+    context 'the current version and a valid value' do
+      should 'not equal zero' do
+        @valid.each do |valid|
+          assert_not_equal 0, @user.versions.between(@version, valid).size
+          assert_not_equal 0, @user.versions.between(valid, @version).size
+        end
+      end
+    end
+
+    context 'the current version and an invalid value' do
+      should 'equal zero' do
+        @invalid.each do |invalid|
+          assert_equal 0, @user.versions.between(@version, invalid).size
+          assert_equal 0, @user.versions.between(invalid, @version).size
+        end
+      end
+    end
+
+    context 'two invalid values' do
+      should 'equal zero' do
+        @invalid.each do |first|
+          @invalid.each do |second|
+            assert_equal 0, @user.versions.between(first, second).size
+            assert_equal 0, @user.versions.between(second, first).size
+          end
+        end
+      end
+    end
+
+    context 'a valid value and an invalid value' do
+      should 'equal zero' do
+        @valid.each do |valid|
+          @invalid.each do |invalid|
+            assert_equal 0, @user.versions.between(valid, invalid).size
+            assert_equal 0, @user.versions.between(invalid, valid).size
+          end
+        end
+      end
+    end
+  end
+end

data/test/changes_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class ChangesTest < Test::Unit::TestCase
+  context "A version's changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should "initially be blank" do
+      assert @user.versions.first.changes.blank?
+    end
+
+    should 'contain all changed attributes' do
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.slice(*changes.keys)
+    end
+
+    should 'contain no more than the changed attributes and timestamps' do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @user.name = 'Steve Jobs'
+      changes = @user.changes
+      @user.save
+      assert_equal changes, @user.versions.last.changes.except(*timestamps)
+    end
+  end
+end

data/test/comparable_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ComparableTest < Test::Unit::TestCase
+  context 'A comparable version' do
+    setup do
+      @version_1 = Version.new(:number => 1)
+      @version_2 = Version.new(:number => 2)
+    end
+
+    should 'equal itself' do
+      assert @version_1 == @version_1
+      assert @version_2 == @version_2
+    end
+
+    context 'with version number 1' do
+      should 'not equal a version with version number 2' do
+        assert @version_1 != @version_2
+      end
+
+      should 'be less than a version with version number 2' do
+        assert @version_1 < @version_2
+      end
+    end
+
+    context 'with version number 2' do
+      should 'not equal a version with version number 1' do
+        assert @version_2 != @version_1
+      end
+
+      should 'be greater than a version with version number 1' do
+        assert @version_2 > @version_1
+      end
+    end
+  end
+end

data/test/creation_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class CreationTest < Test::Unit::TestCase
+  context 'The number of versions' do
+    setup do
+      @name = 'Steve Richert'
+      @user = User.create(:name => @name)
+      @count = @user.versions.count
+    end
+
+    should 'initially equal one' do
+      assert_equal 1, @count
+    end
+
+    should 'not increase when no changes are made in an update' do
+      @user.name =  @name
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when no changes are made before a save' do
+      @user.save
+      assert_equal @count, @user.versions.count
+    end
+
+    should 'not increase when reverting to the current version' do
+      @user.revert_to!(@user.version)
+      assert_equal @count, @user.versions.count
+    end
+
+    context 'after an update' do
+      setup do
+        @initial_count = @count
+        @name = 'Steve Jobs'
+        @user.name = @name
+        @user.save
+        @count = @user.versions.count
+      end
+
+      should 'increase by one' do
+        assert_equal @initial_count + 1, @count
+      end
+
+      should 'increase by one when reverted' do
+        @user.revert_to!(:first)
+        assert_equal @count + 1, @user.versions.count
+      end
+
+      should 'not increase until a revert is saved' do
+        @user.revert_to(:first)
+        assert_equal @count, @user.versions.count
+        @user.save
+        assert_not_equal @count, @user.versions.count
+      end
+    end
+    
+    should "retrieve a specific version without reverting it" do
+      @user.name = "Hoge"
+      @user.save
+      version_count = @user.versions.size
+      @user.retrieve_version 2
+      assert_equal version_count, @user.versions.size
+    end
+
+    context 'after multiple updates' do
+      setup do
+        @initial_count = @count
+        @new_name = 'Steve Jobs'
+        @user.name = @new_name
+        @user.name = @name
+        @count = @user.versions.count
+      end
+
+      should 'not increase when reverting to an identical version' do
+        @user.revert_to!(:first)
+        assert_equal @count, @user.versions.count
+      end
+    end
+  end
+end

data/test/latest_changes_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class LatestChangesTest < Test::Unit::TestCase
+  context "A created model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+    end
+
+    should 'be blank' do
+      assert @user.latest_changes.blank?
+    end
+  end
+
+  context "An updated model's last changes" do
+    setup do
+      @user = User.create(:name => 'Steve Richert')
+      @previous_attributes = @user.attributes
+      @user.name = 'Steve Jobs'
+      @current_attributes = @user.attributes
+    end
+
+    should 'values of two-element arrays with unique values' do
+      @user.latest_changes.values.each do |value|
+        assert_kind_of Array, value
+        assert_equal 2, value.size
+        assert_equal value, value.uniq
+      end
+    end
+
+    should 'begin with the previous attribute values' do
+      changes = @user.latest_changes.inject({}){|h,(k,v)| h.update(k => v.first) }
+      previous = @previous_attributes.slice(*@user.latest_changes.keys)
+      assert_equal previous, changes
+    end
+
+    should 'end with the current attribute values' do
+      changes = @user.latest_changes.inject({}){|h,(k,v)| h.update(k => v.last) }
+      current = @current_attributes.slice(*@user.latest_changes.keys)
+      assert_equal current, changes
+    end
+  end
+end

data/test/revert_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class RevertTest < Test::Unit::TestCase
+  context 'A model reversion' do
+    setup do
+      @user, @attributes, @times = User.new, {}, {}
+      names = ['Steve Richert', 'Stephen Richert', 'Stephen Jobs', 'Steve Jobs']
+      time = names.size.hours.ago
+      names.each do |name|
+        @user.update_attributes({:name => name})
+        @attributes[@user.version] = @user.attributes
+        time += 1.hour
+        @user.versions.last.update_attributes({:created_at => time})
+        @times[@user.version] = time
+      end
+      @first_version, @last_version = @attributes.keys.min, @attributes.keys.max
+    end
+
+    should 'do nothing for a non-existent version' do
+      attributes = @user.attributes
+      @user.revert_to!(nil)
+      assert_equal attributes, @user.attributes
+    end
+
+    should 'return the new version number' do
+      new_version = @user.revert_to(@first_version)
+      assert_equal @first_version, new_version
+    end
+
+    should 'change the version number when saved' do
+      current_version = @user.version
+      @user.revert_to!(@first_version)
+      assert_not_equal current_version, @user.version
+    end
+
+    should 'be able to target the first version' do
+      @user.revert_to(:first)
+      assert_equal @first_version, @user.version
+    end
+
+    should 'be able to target the last version' do
+      @user.revert_to(:last)
+      assert_equal @last_version, @user.version
+    end
+
+    should 'do nothing for a non-existent method name' do
+      current_version = @user.version
+      @user.revert_to(:bogus)
+      assert_equal current_version, @user.version
+    end
+
+    should 'be able to target a version number' do
+      @user.revert_to(1)
+      assert 1, @user.version
+    end
+
+    should 'be able to target a date and time' do
+      @times.each do |version, time|
+        @user.revert_to(time + 1.second)
+        assert_equal version, @user.version
+      end
+    end
+
+    should 'be able to target a version object' do
+      @user.versions.each do |version|
+        @user.revert_to(version)
+        assert_equal version.number, @user.version
+      end
+    end
+
+    should "correctly roll back the model's attributes" do
+      timestamps = %w(created_at created_on updated_at updated_on)
+      @attributes.each do |version, attributes|
+        @user.revert_to!(version)
+        assert_equal attributes.except(*timestamps), @user.attributes.except(*timestamps)
+      end
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,21 @@
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1')
+MongoMapper.database = "testing_versioned"
+
+class User
+  include MongoMapper::Document
+  include Versioned
+  key :first_name, String
+  key :last_name, String
+  timestamps!
+  
+  def name
+    [first_name, last_name].compact.join(' ')
+  end
+
+  def name=(names)
+    self[:first_name], self[:last_name] = names.split(' ', 2)
+  end
+end
+
+User.destroy_all
+Version.destroy_all

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mongo_mapper'
+require 'versioned'
+require 'schema'
+begin; require 'redgreen'; rescue LoadError; end

data/versioned.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{versioned}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["twoism", "toastyapps", "jacqui"]
+  s.date = %q{2009-12-17}
+  s.description = %q{Versioning for MongoMapper}
+  s.email = %q{signalstatic@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/version.rb",
+     "lib/versioned.rb",
+     "pkg/versioned-0.1.0.gem",
+     "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/latest_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_helper.rb",
+     "versioned.gemspec"
+  ]
+  s.homepage = %q{http://github.com/twoism/versioned}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Versioning for MongoMapper}
+  s.test_files = [
+    "test/between_test.rb",
+     "test/changes_test.rb",
+     "test/comparable_test.rb",
+     "test/creation_test.rb",
+     "test/latest_changes_test.rb",
+     "test/revert_test.rb",
+     "test/schema.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: versioned
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- twoism
+- toastyapps
+- jacqui
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-17 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Versioning for MongoMapper
+email: signalstatic@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/version.rb
+- lib/versioned.rb
+- pkg/versioned-0.1.0.gem
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/latest_changes_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- versioned.gemspec
+has_rdoc: true
+homepage: http://github.com/twoism/versioned
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Versioning for MongoMapper
+test_files: 
+- test/between_test.rb
+- test/changes_test.rb
+- test/comparable_test.rb
+- test/creation_test.rb
+- test/latest_changes_test.rb
+- test/revert_test.rb
+- test/schema.rb
+- test/test_helper.rb