yesterday 0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+yesterday.db

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in yesterday.gemspec
+gemspec
+
+gem 'rails'
+gem 'rspec'
+gem 'sqlite3'

data/README.rdoc

@@ -0,0 +1,86 @@
+= Yesterday
+
+The Yesterday gem lets you track changes made in ActiveRecord models. It's also possible to diff different versions. The big difference with this gem and other is, is that it is possible to diff all child objects (has_many, belongs_to & has_and_belongs_to_many) and it's changes.
+
+== Note: work in progress
+
+In the meanwhile:
+http://www.youtube.com/watch?v=YgtByWlBSdA
+
+== Installation
+
+Install the gem:
+  gem install yesterday
+
+And then run the generator in your Rails 3 project:
+  rails generate yesterday:install
+
+== Use tracking in your models
+
+  class Contact < ActiveRecord::Base
+    has_many :addresses
+    tracks_changes
+  end
+
+  class Address < ActiveRecord::Base
+    has_many :companies
+    exclude_tracking_for :associations => :companies
+  end
+
+== Checking version number
+
+  some_contact = Contact.find(10)
+  some_contact.version_number
+
+== Viewing historical data of an object
+
+Viewing a version from an already found active record model:
+  some_contact = Contact.find(10)
+  some_contact.version(2)
+
+Or using in a scope chain:
+  Contact.where(:first_name => 'foo').last.version(3)
+
+Both of the above examples will return a Yesterday::VersionedObject
+  contact = Contact.create :first_name => 'foo'
+  contact.update_attribute :first_name => 'baz'
+
+  puts contact.version(1).first_name # -> foo
+  puts contact.version(2).first_name # -> baz
+
+== Diffing two versions
+
+Use version numbers two compare two versions:
+  contact = Contact.create :first_name => 'foo'
+  contact.update_attribute :first_name => 'baz'
+
+  diff = contact.diff_version(1, 2)
+  puts diff.first_name.current # -> baz
+  puts diff.first_name.previous # -> foo
+
+Diff's within associations:
+  address = [Address.new(:address => 'blah')]
+
+  contact = Contact.new :first_name => 'foo'
+  contact.addresses = [address]
+  contact.save!
+
+  contact.addresses.first.address = 'blahblah'
+  contact.save!
+
+  diff = contact.diff_version(1, 2)
+  puts diff.addresses.first.address.current # -> blahblah
+  puts diff.addresses.first.address.previous # -> foo
+
+
+To check if associations are created, just use the created_ prefix before the appropiate association:
+  contact.created_addresses
+
+Or, for removed associations:
+  contact.destroyed_addresses
+
+
+= License and credits
+Use it and have fun with it! Comments, cakes and hugs are welcome! Just stick to the license!
+
+Copyright 2011, Diederick Lawson - Altovista. Released under the FreeBSD license.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/generators/yesterday/install_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'rails/generators/active_record/migration'
+
+module Yesterday
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    extend ActiveRecord::Generators::Migration
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc 'Generates a migration to add the changesets table in order to use tracks_changes in your models'
+    def create_migration_file
+      migration_template 'create_changesets.rb', 'db/migrate/create_changesets.rb'
+    end
+  end
+end
+

data/lib/generators/yesterday/templates/create_changesets.rb

@@ -0,0 +1,17 @@
+class CreateChangesets < ActiveRecord::Migration
+  def self.up
+    create_table :changesets do |t|
+      t.integer :changed_object_id
+      t.string :changed_object_type
+      t.text :object_attributes
+      t.integer :version_number
+      t.datetime :created_at
+      t.datetime :updated_at
+    end
+  end
+
+  def self.down
+    drop_table :changesets
+  end
+end
+

data/lib/yesterday/changeset.rb

@@ -0,0 +1,40 @@
+module Yesterday
+  class Changeset < ActiveRecord::Base
+
+    before_create :determine_version_number, :determine_object_attributes
+    belongs_to :changed_object, :polymorphic => true
+
+    serialize :object_attributes
+
+    def self.version(version_number)
+      where(:version_number => version_number)
+    end
+
+    def self.for_changed_object(object)
+      where(:changed_object_type => object.class.to_s, :changed_object_id => object.id)
+    end
+
+    def self.last_for(object)
+      for_changed_object(object).order('created_at DESC').first
+    end
+
+    def self.version_number_for(object)
+      last_for(object).try(:version_number) || 0
+    end
+
+    def object
+      @object ||= VersionedObjectCreator.new(object_attributes).to_object if object_attributes.present?
+    end
+
+    private
+
+    def determine_version_number
+      self.version_number = self.class.version_number_for(changed_object) + 1
+    end
+
+    def determine_object_attributes
+      self.object_attributes = Yesterday::Serializer.new(changed_object).to_hash
+    end
+
+  end
+end

data/lib/yesterday/differ.rb

@@ -0,0 +1,99 @@
+module Yesterday
+  class Differ < Struct.new(:from, :to)
+
+    def diff
+      @diff ||= diff_object(from, to)
+    end
+
+    private
+
+    def diff_object(from, to)
+      diff = diff_attributes(from, to)
+
+      diff.merge! diff_collection(from, to)
+      diff.merge! diff_created_objects(from, to)
+      diff.merge! diff_destroyed_objects(from, to)
+
+      diff
+    end
+
+    def diff_attributes(from, to)
+      diff = {}
+
+      from.each do |attribute, old_value|
+        if attribute == 'id'
+          diff[attribute] = old_value
+        elsif !old_value.is_a?(Array)
+          new_value = to[attribute]
+          diff[attribute] = [old_value, new_value]
+        end
+      end
+
+      diff
+    end
+
+    def diff_collection(from, to)
+      diff = {}
+
+      from.each do |attribute, old_objects|
+        if old_objects.is_a? Array
+          new_objects = to[attribute]
+
+          old_objects.each do |old_object|
+            new_object = find_object(new_objects, old_object['id'])
+
+            if new_object
+              diff[attribute] ||= []
+              diff[attribute] << diff_object(old_object, new_object)
+            end
+          end
+        end
+      end
+
+      diff
+    end
+
+    def diff_created_objects(from, to)
+      diff_object_creation from, to, 'created'
+    end
+
+    def diff_destroyed_objects(from, to)
+      diff_object_creation to, from, 'destroyed'
+    end
+
+    def diff_object_creation(from, to, event)
+      diff = {}
+
+      to.each do |attribute, to_objects|
+        if to_objects.is_a? Array
+          from_objects = from[attribute] || []
+
+          to_objects.each do |to_object|
+            from_object = find_object(from_objects, to_object['id'])
+
+            unless from_object
+              diff["#{event}_#{attribute}"] ||= []
+              diff["#{event}_#{attribute}"] << to_object
+            end
+          end
+        end
+      end
+
+      diff
+    end
+
+    def find_object(array, id)
+      index = array.find_index { |object| object['id'] == id }
+      array[index] if index
+    end
+
+    def is_same_object?(from, to)
+      from['id'] == to['id']
+    end
+
+    def has_collection?(value)
+      value.is_a? Array
+    end
+
+  end
+end

data/lib/yesterday/model.rb

@@ -0,0 +1,100 @@
+module Yesterday
+  module Model
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def exclude_tracking_for(options)
+        if options[:associations]
+          @excluded_tracked_associations ||= []
+          @excluded_tracked_associations += Array(options[:associations]).map(&:to_s)
+        end
+
+        if options[:attributes]
+          @excluded_tracked_attributes ||= []
+          @excluded_tracked_attributes += Array(options[:attributes]).map(&:to_s)
+        end
+      end
+
+      def include_tracking_for(options)
+        if options[:associations]
+          @tracked_associations ||= []
+          @tracked_associations += Array(options[:associations]).map(&:to_s)
+        end
+
+        if options[:attributes]
+          @tracked_attributes ||= []
+          @tracked_attributes += Array(options[:attributes]).map(&:to_s)
+        end
+      end
+
+      def excluded_tracked_associations
+        @excluded_tracked_associations || []
+      end
+
+      def excluded_tracked_attributes
+        @excluded_tracked_attributes || []
+      end
+
+      def tracked_associations
+        @tracked_associations || []
+      end
+
+      def tracked_attributes
+        @tracked_attributes || []
+      end
+
+      def tracks_changes(options = {})
+        send :include, InstanceMethods
+
+        after_save :serialize_current_state
+        exclude_tracking_for :associations => :changesets
+      end
+
+      def version(version_number)
+        if object = first
+          Versioning.versioned_object_for(version_number, object)
+        end
+      end
+
+      def diff_version(from_version_number, to_version_number)
+        if object = first
+          Versioning.diff_for(from_version_number, to_version_number, object)
+        end
+      end
+
+    end
+
+    module InstanceMethods
+      def changesets
+        Versioning.changesets_for(self)
+      end
+
+      def version_number
+        Versioning.current_version_number_for(self)
+      end
+
+      def previous_version_number
+        version_number > 1 ? version_number - 1 : version_number
+      end
+
+      def version(version_number)
+        Versioning.versioned_object_for(version_number, self)
+      end
+
+      def diff_version(from_version_number, to_version_number)
+        Versioning.diff_for(from_version_number, to_version_number, self)
+      end
+
+      private
+
+      def serialize_current_state
+        Versioning.create_changeset_for self
+      end
+
+    end
+
+  end
+end

data/lib/yesterday/serializer.rb

@@ -0,0 +1,88 @@
+module Yesterday
+  class Serializer < Struct.new(:object)
+
+    def to_hash
+      @hash ||= hash_object(object)
+    end
+
+    private
+
+    def hash_object(object)
+      hash = {}
+      hash.merge! attributes_for(object)
+
+      each_association_collection(object) do |association, association_name, item|
+        path << object
+
+        if assocation_has_collection?(association)
+          hash[association_name] ||= []
+          hash[association_name] << hash_object(item)
+        else
+          hash[association_name] = hash_object(item)
+        end
+
+        path.pop
+      end
+
+      hash
+    end
+
+    def assocation_has_collection?(association)
+      [:has_many, :has_and_belongs_to_many].include? association.macro
+    end
+
+    def have_visited_object?(object)
+      self.object == object || path.include?(object)
+    end
+
+    def each_association_collection(object)
+      associations_for(object).each do |association|
+        association_name = association.name.to_s
+
+        association_collection(object, association_name).each do |item|
+          yield(association, association_name, item) unless have_visited_object?(item)
+        end
+      end
+    end
+
+    def attributes_for(object)
+      attributes = object.attributes.dup
+
+      if object.class.respond_to?(:tracked_attributes) && object.class.tracked_attributes.present?
+        attributes.except!(*(attributes.keys - object.class.tracked_attributes))
+      end
+
+      if object.class.respond_to?(:excluded_tracked_attributes) && object.class.excluded_tracked_attributes.present?
+        attributes.except!(*object.class.excluded_tracked_attributes)
+      end
+
+      attributes
+    end
+
+    def associations_for(object)
+      associations = object.class.reflect_on_all_associations
+
+      tracked_associations = object.class.respond_to?(:tracked_associations) ? object.class.tracked_associations : []
+      ignored_associations = object.class.respond_to?(:excluded_tracked_associations) ? object.class.excluded_tracked_associations : []
+
+      associations.select do |association|
+        ( !ignored_associations.include?(association.name.to_s) &&
+          ( tracked_associations.empty? ||
+            tracked_associations.include?(association_name.to_s)) )
+      end
+    end
+
+    def association_collection(object, association_name)
+      object.send(association_name).to_a
+    end
+
+    def visited_objects
+      @visited_objects ||= []
+    end
+
+    def path
+      @path ||= []
+    end
+
+  end
+end

data/lib/yesterday/version.rb

@@ -0,0 +1,3 @@
+module Yesterday
+  VERSION = "0.2"
+end

data/lib/yesterday/versioned_attribute.rb

@@ -0,0 +1,21 @@
+module Yesterday
+  class VersionedAttribute < Struct.new(:diff)
+
+    def current
+      diff.last
+    end
+
+    def previous
+      diff.first
+    end
+
+    def to_s
+      current.to_s
+    end
+
+    def to_i
+      current.to_i
+    end
+
+  end
+end

data/lib/yesterday/versioned_object.rb

@@ -0,0 +1,18 @@
+module Yesterday
+  class VersionedObject < Struct.new(:attributes)
+
+    def id
+      attributes['id']
+    end
+
+    def method_missing(method, *arguments, &block)
+      if attributes.has_key?(method.to_s)
+        attributes[method.to_s]
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/yesterday/versioned_object_creator.rb

@@ -0,0 +1,33 @@
+module Yesterday
+  class VersionedObjectCreator < Struct.new(:hash)
+
+    def to_object
+      @object ||= deserialize(hash)
+    end
+
+    private
+
+    def deserialize(hash)
+      attributes = {}
+
+      hash.each do |attribute, value|
+        if nested_value? value
+          value.each do |item|
+            attributes[attribute] ||= []
+            attributes[attribute] << deserialize(item)
+          end
+
+        elsif attribute != 'id'
+          attributes[attribute] = value.is_a?(Array) ? Yesterday::VersionedAttribute.new(value) : value
+        end
+      end
+
+      Yesterday::VersionedObject.new(attributes.merge({ 'id' => hash['id']}))
+    end
+
+    def nested_value?(value)
+      value.is_a?(Array) && value.first.is_a?(Hash)
+    end
+
+  end
+end

data/lib/yesterday/versioning.rb

@@ -0,0 +1,40 @@
+module Yesterday
+  class Versioning
+    class << self
+      def create_changeset_for(object)
+        Changeset.create :changed_object => object
+      end
+
+      def changesets_for(object)
+        Changeset.for_changed_object(object)
+      end
+
+      def current_version_number_for(object)
+        changesets_for(object).last.try(:version_number) || 0
+      end
+
+      def versioned_object_for(version_number, object)
+        changeset_for(version_number, object).try(:object)
+      end
+
+      def diff_for(from_version_number, to_version_number, object)
+        from_attributes = object_attributes_for(from_version_number, object)
+        to_attributes   = object_attributes_for(to_version_number, object)
+        diff            = Differ.new(from_attributes, to_attributes).diff
+
+        VersionedObjectCreator.new(diff).to_object
+      end
+
+      private
+
+      def changeset_for(version_number, object)
+        Changeset.for_changed_object(object).version(version_number).first
+      end
+
+      def object_attributes_for(version_number, object)
+        changeset_for(version_number, object).object_attributes
+      end
+
+    end
+  end
+end

data/lib/yesterday.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_record'
+
+require 'yesterday/changeset'
+require 'yesterday/versioning'
+require 'yesterday/differ'
+require 'yesterday/versioned_object_creator'
+require 'yesterday/versioned_object'
+require 'yesterday/versioned_attribute'
+require 'yesterday/model'
+require 'yesterday/serializer'
+require 'yesterday/version'
+
+ActiveSupport.on_load(:active_record) do
+  include Yesterday::Model
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: yesterday.db