deja_vue 0.1.2

data/Manifest

@@ -0,0 +1,9 @@
+Manifest
+README.rdoc
+Rakefile
+deja_vue.gemspec
+lib/deja_vue.rb
+lib/deja_vue/has_deja_vue.rb
+lib/deja_vue/history.rb
+lib/deja_vue/version.rb
+rails/init.rb

data/README.rdoc

@@ -0,0 +1,75 @@
+= DejaVue
+
+Yet another gem to store version of your models. But it uses mongodb as 
+backend. Based on PaperTrail (http://github.com/airblade/paper_trail/).
+
+== Why choose DejaVue
+
+The main goal of DejaVue is to keep track of associated models. It's 
+useful for a model whose relations change among time and to see how
+it really looked like at a certain point.
+
+There are 3 kinds of versioning: create, update, destroy
+Differently from PaperTrail, each version will record the current model info.
+So PapelTrail _create_ versions have reify == nil
+DejaVue have _create_ version == model_version_when_creating
+
+== Installing
+
+  $ bundle install
+	$ gem install gemcutter
+  $ gem build deja_vue.gemspec
+  $ gem install ./deja_vue-*.gem
+
+== Beggining with DejaVue: Add to your model
+
+Add a single line and your model will start beeing versionated:
+
+def SomeModel < ActiveRecord::Base
+ has_deja_vue
+end
+
+Or, for example, use the ignore option:
+
+def SomeModel < ActiveRecord::Base
+ has_deja_vue :ignore => :location
+end
+
+
+== More Options
+
+ You might pass some options, including:
+ :ignore                 | An Array of fields that will be ignored. If
+                         | only those fields have changed, then no version
+                         | will be created.
+                         | has_deja_vue :ignore => :last_exported_on
+ :associations           | Store associated models to be record with the model
+                         | so it can be fully restored. Right now it works only
+                         | with has_one / belongs_to relationships.
+                         | Ex.:
+                         | class Account < ActiveRecord::Base
+                         |   has_one :account_preference
+                         |
+                         |   has_deja_vue :associations => [:account_preference]
+                         | end
+                         |
+ :extra_info_fields      | Almost the same as the above option. But it handles
+                         | more simple info (like strings, integers, floats).
+                         | Useful to store a tag_list field or a counter cache
+                         | Ex:
+                         |
+                         | class BlogPost < ActiveRecord::Base
+                         |   acts_as_taggable_on :tags
+                         |
+                         |   has_deja_vue :extra_info_fields => [:tag_list]
+                         | end
+                         |
+ :who_did_it             | a default value for record who_did_it when you
+                         | are not in a request-response cycle (ex. in a job).
+                         | Ex.:
+                         | has_deja_vue :who_did_it => 'admin'
+                         | Alternatively you are able to set the user right
+                         | before save the model that will be versionated, using:
+                         | DejaVue.who_did_it = 'otavio'
+                         | SomeModel.save
+

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  # Rspec 1.3.0
+  require 'spec/rake/spectask'
+  desc 'Default: run specs'
+  task :default => :spec
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList["spec/**/*_spec.rb"]
+  end
+
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = FileList["spec/**/*_spec.rb"]
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+
+rescue LoadError
+  puts "Rspec not available. Install it with: gem install rspec"  
+end
+

data/deja_vue.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'deja_vue/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{deja_vue}
+  s.version = DejaVue::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Riopro Informatica Ltda"]
+  s.date = %q{2010-08-11}
+  s.description = %q{DejaVue -> Ruby versioning Gem using MongoDB as backend}
+  s.email = %q{riopro@riopro.com.br}
+  s.extra_rdoc_files = ["README.rdoc", "lib/deja_vue.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "deja_vue.gemspec", "lib/deja_vue.rb", "lib/deja_vue/has_deja_vue.rb", "lib/deja_vue/history.rb", "rails/init.rb"]
+  s.homepage = %q{http://github.com/riopro/deja_vue}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "deja_vue", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{deja_vue}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Keep track of your models changing history, using MongoDB as backend}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+  end
+end

data/lib/deja_vue.rb

@@ -0,0 +1,98 @@
+require 'deja_vue/has_deja_vue'
+require 'deja_vue/history'
+
+# Based on PaperTrail (http://github.com/airblade/paper_trail/).
+# Using:
+# Add an initializer at config/initializers and require 'deja_vue'
+# Add to your model:
+# has_deja_vue
+# You might pass some options, including:
+# :ignore                 | An Array of fields that will be ignored. If
+#                         | only those fields have changed, then no version
+#                         | will be created.
+#                         | has_deja_vue :ignore => :last_exported_on
+# :associations           | Store associated models to be record with the model
+#                         | so it can be fully restored. Right now it works only
+#                         | with has_one / belongs_to relationships.
+#                         | Ex.:
+#                         | class Account < ActiveRecord::Base
+#                         |   has_one :account_preference
+#                         |
+#                         |   has_deja_vue :associations => [:account_preference]
+#                         | end
+#                         |
+# :extra_info_fields      | Almost the same as the above option. But it handles
+#                         | more simple info (like strings, integers, floats).
+#                         | Useful to store a tag_list field or a counter cache
+#                         | Ex:
+#                         |
+#                         | class BlogPost < ActiveRecord::Base
+#                         |   acts_as_taggable_on :tags
+#                         |
+#                         |   has_deja_vue :extra_info_fields => [:tag_list]
+#                         | end
+#                         |
+# :who_did_it             | a default value for record who_did_it when you
+#                         | are not in a request-response cycle (ex. in a job).
+#                         | Ex.:
+#                         | has_deja_vue :who_did_it => 'admin'
+#                         | Alternatively you are able to set the user right
+#                         | before save the model that will be versionated, using:
+#                         | DejaVue.who_did_it = 'otavio'
+#                         | SomeModel.save
+#
+# There are 3 kinds of versioning: create, update, destroy
+# Differently from PaperTrail, each version will record the current model info.
+# So PapelTrail _create_ versions have reify == nil
+# DejaVue have _create_ version == model_version_when_creating
+module DejaVue
+
+  def self.included(base)
+    base.before_filter :set_deja_vue_user
+  end
+
+  def self.who_did_it
+    Thread.current[:who_did_it]
+  end
+
+  def self.who_did_it=(value)
+    Thread.current[:who_did_it] = value
+  end
+
+  # Used to set an user to be versionated, execute the block and
+  # then rollback to the thread's regular user.
+  # Example:
+  #
+  # @blog_post = BlogPost.find 10
+  # @blog_post.title = "new title"
+  # DejaVue.setting_user_as('someone') do
+  #   @blog_post.save
+  # end
+  def self.setting_user_as(value, &block)
+    actual_user = Thread.current[:who_did_it]
+    Thread.current[:who_did_it] = value
+    yield if block_given?
+    Thread.current[:who_did_it] = actual_user
+  end
+
+  protected
+
+    # Returns the user who is responsible for any changes that occur.
+    # By default this calls `current_user` and returns the result.
+    #
+    # Override this method in your controller to call a different
+    # method, e.g. `current_person`, or anything you like.
+    def user_for_deja_vue
+			return current_user if current_user && current_user.is_a?(String)
+			current_user[:id] if current_user && current_user[:id]
+    end
+
+  private
+
+    # Verifies if current controller responds to current_user method
+    def set_deja_vue_user
+      Thread.current[:who_did_it] = user_for_deja_vue
+    end
+end
+
+ActionController::Base.send :include, DejaVue

data/lib/deja_vue/has_deja_vue.rb

@@ -0,0 +1,85 @@
+module DejaVue
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+
+  module ClassMethods
+    # Options:
+    # :ignore    an array of attributes for which a new +Version+ will not be created if only they change.
+    def has_deja_vue(options = {})
+      send :include, InstanceMethods
+
+      cattr_accessor :deja_vue_options
+      options[:ignore] = options[:ignore].map &:to_s if options[:ignore]
+      self.deja_vue_options = options
+
+      cattr_accessor :deja_vue_active
+      self.deja_vue_active = true
+
+      before_save :check_for_version_changes
+      after_update :record_update_version
+      after_create :record_create_version
+      after_destroy :record_destroy_version
+
+    end
+
+		# FIXME: not implemented yet
+    def deja_vue_off
+      self.deja_vue_active = false
+    end
+
+		# FIXME: not implemented yet
+    def deja_vue_on
+      self.deja_vue_active = true
+    end
+  end
+
+  module InstanceMethods
+
+    # return array with changed fields after object has been saved
+		# (created or updated). 
+		# Whe need this to validate if the changes must be recorded after save
+    def version_changes
+      @version_changes
+    end
+
+    # Search for all change history from the current object
+    def histories(extra_options={})
+      default_options = {:versionable_type => self.class.to_s, :versionable_id => self.id.to_s}
+      History.where(extra_options.merge(default_options)).sort(:created_at.desc).all
+    end
+
+    # Search for a change history from the current object by id
+    def history(param_id)
+      History.where(:versionable_type => self.class.to_s, :versionable_id => self.id.to_s, :id => param_id).first
+    end
+
+    private
+
+      def check_for_version_changes
+        @version_changes = self.changed
+      end
+
+      def versionate_as(kind_of_version)
+        History.versionate(self, kind_of_version, deja_vue_options.merge(:who_did_it => DejaVue.who_did_it)) if DejaVue.who_did_it
+        History.versionate(self, kind_of_version, deja_vue_options) unless DejaVue.who_did_it
+      end
+
+      def record_update_version
+        versionate_as("update")
+      end
+
+      def record_create_version
+        versionate_as("create")
+      end
+
+      def record_destroy_version
+        versionate_as("destroy")
+      end
+  end
+
+end
+
+ActiveRecord::Base.send :include, DejaVue

data/lib/deja_vue/history.rb

@@ -0,0 +1,184 @@
+class History
+  include MongoMapper::Document
+
+  key :versionable_type,    String,  :required => true, :index => true
+  key :versionable_id,      String,  :required => true, :index => true
+  key :kind_of_version,     String,  :required => true
+  key :version_attributes,  Hash,   :required => true
+  key :version_associations,Hash,   :index => true
+  key :extra_info,          Hash  # para armazenar informações relacionadas, como tag_list
+  key :changed_fields,      Array
+  key :who_did_it,          String
+  timestamps!
+  ensure_index :created_at
+
+
+  #
+  # Validations
+  #
+  validates_true_for :version_attributes, :logic => lambda { !version_attributes.empty? }
+
+  #
+  # Constants
+  #
+
+  DEFAULT_IGNORED_FIELDS = ["updated_at", "created_at"]
+
+  KIND_OF_VERSIONS = %w( create update destroy )
+  
+  #
+  # Class Methods
+  #
+
+  def self.versionate(object, kind_of_version, options={})
+    return false if object.blank?
+    History.new.create_version(object, kind_of_version, options)
+  end
+
+  # marreta para teste rodar, por causa do i18n do remarkable, FIXME
+  def self.human_name(foo)
+    "History"
+  end
+
+  #
+  # Instance Methods
+  #
+
+  def create_version(object, kind_of_version, options={})
+    self.ignored_fields= options[:ignore] if options[:ignore]
+    self.who_did_it = check_and_retrieve_user(options[:who_did_it]) if options[:who_did_it]
+    self.kind_of_version  = kind_of_version
+    self.versionable_type = object.class.name
+    self.versionable_id   = object.id.to_s
+
+    unless self.kind_of_version == "destroy"
+      return false unless self.has_changed?(object)
+    end
+    self.version_attributes = attributes_filter(object.attributes)
+    store_version_associations object, options
+    store_extra_info(object, options)
+    self.save
+  end
+
+  # Rebuild the versionated object.
+  # Do not rebuild if it's not saved
+  def version
+    return nil if self.new_record?
+    @version ||= recreate_version_object
+  end
+
+  # fields that whose change won't cause a history trace
+  def ignored_fields
+    @ignored_fields || DEFAULT_IGNORED_FIELDS
+  end
+
+  def ignored_fields=(fields_array)
+    fields = nil
+    fields = fields_array if fields_array.is_a?(Array)
+    fields = [fields_array.to_s] if ( fields_array.is_a?(String) || fields_array.is_a?(Symbol) )
+    return false unless fields.is_a?(Array)
+    @ignored_fields = ( DEFAULT_IGNORED_FIELDS  + fields ).uniq
+  end
+
+  # return true id object has changed
+  def has_changed?(object)
+    return false unless object.try(:version_changes)    
+    !store_changed_fields(object).empty?
+  end
+
+  def next_version
+    History.where(:created_at.gte => self.created_at,  # could have the same creation date, as long it's not the same object
+                      :id.ne => self.id,              # ne => not equal to
+                      :versionable_type => self.versionable_type,
+                      :versionable_id => self.versionable_id).sort(:created_at.asc).first
+  end
+
+  def previous_version
+    History.where(:created_at.lte => self.created_at,  # could have the same creation date, as long it's not the same object
+                      :id.ne => self.id,              # ne => not equal to
+                      :versionable_type => self.versionable_type,
+                      :versionable_id => self.versionable_id).sort(:created_at.desc).first
+  end
+
+  protected
+
+    # Retrieve the versionated object
+    def recreate_version_object
+      model = recreate_model(self.versionable_type, self.version_attributes)
+      model.id = self.versionable_id
+
+      self.version_associations.each do |associated_object, associated_object_attributes|
+        model.try "#{associated_object.to_s}=", recreate_model(associated_object, associated_object_attributes)
+      end
+      update_fields model, self.extra_info
+      model
+    end
+
+    # recreates object from a class name and its attributes
+    def recreate_model(class_name, attributes_hash={})
+      associated_klass = class_name.to_s.camelize.constantize.new
+      update_fields associated_klass, attributes_hash
+      associated_klass
+    end
+
+    # updates values for an instantiated class
+    def update_fields(class_object, attributes_hash={})
+      attributes_hash.each do |key, value|
+        class_object.send "#{key.to_s}=", value
+      end
+    end
+
+    # If user is a Class, try to retrieve user
+    # from an Authlogic User Session.
+    # If it is an Authlogic object, return the user id.
+    #
+    # Else it returns the current object.
+    def check_and_retrieve_user(user)
+      if user.is_a? Class
+        begin
+          user.find.user.id
+        rescue
+          nil
+        end
+      else
+        user
+      end
+    end
+
+    def store_version_associations(object, options)
+      self.version_associations = {}
+      options[:associations].each do |association|
+        self.version_associations.store(association, attributes_filter( object.try(association).attributes) ) if object.try(association)
+      end if options[:associations]
+      true
+    end
+
+    def store_changed_fields(object)
+      self.changed_fields = object.version_changes - self.ignored_fields if self.ignored_fields.is_a?(Array)
+      self.changed_fields
+    end
+
+    def store_extra_info(object, options)
+      self.extra_info = {}
+      options[:extra_info_fields].each do |extra_info|
+        self.extra_info.store( extra_info, object.try(extra_info) ) if object.try(extra_info)
+      end if options[:extra_info_fields]
+      self.extra_info = attributes_filter(self.extra_info)
+      true
+    end
+
+    def attributes_filter(key_value={})
+      key_value.each do |k,v|
+        key_value[k]=v.to_s if key_value[k].is_a?(Date)
+      end
+      key_value.each do |k,v|
+        key_value[k]=v.utc.to_s if key_value[k].is_a?(Time)
+      end
+      key_value.each do |k,v|
+        key_value[k]=v.to_f if key_value[k].is_a?(BigDecimal)
+      end
+
+      key_value
+    end
+
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+config.after_initialize do
+  require 'deja_vue'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: deja_vue
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Riopro Informatica Ltda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-11 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: DejaVue -> Ruby versioning Gem using MongoDB as backend
+email: riopro@riopro.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/deja_vue.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- deja_vue.gemspec
+- lib/deja_vue.rb
+- lib/deja_vue/has_deja_vue.rb
+- lib/deja_vue/history.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/riopro/deja_vue
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- deja_vue
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: deja_vue
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Keep track of your models changing history, using MongoDB as backend
+test_files: []
+