active_metadata 0.0.2 → 0.1.9

data/features/step_definitions/trigger_alert_on_modify_steps.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+# Given ##########################################################                                           
+Given /^an ActiveRecord instance of 'Document' with 'name' equals to "([^"]*)"$/ do |name|
+  raise unless Document.ancestors.include?(::ActiveRecord::Base)
+  @document = Document.create!(:name => name, :surname => 'Garden' )
+end
+
+Given /^a User "([^"]*)" instantiated$/ do |email|
+  @current_user = User.create!(:email => email, :firstname => 'John', :lastname => 'smith' )
+end
+
+Given /^a watcher on the "([^"]*)" field$/ do |attribute|
+  @attribute = attribute
+  @document.create_watcher_for(@attribute, @current_user)
+end
+
+# When ##########################################################
+When /^saving a new value "([^"]*)" on the "([^"]*)" field$/ do |value, attribute|
+  @document.send("#{attribute}=", value)
+  @document.save!
+end
+
+When /^creating a new note on the "([^"]*)" field with content "([^"]*)"$/ do |field, content|
+  @document.create_note_for(field.to_sym, content)
+end
+   
+When /^afterwards I update the note on the field "([^"]*)" with content "([^"]*)"$/ do |field, content|
+  note = @document.notes_for(field.to_sym).first
+  @document.update_note(note.id, content)
+end
+
+When /^afterwards I delete the note on the field "([^"]*)"$/ do |field|
+  note = @document.notes_for(field.to_sym).first
+  @document.delete_note_for(field.to_sym,note.id)  
+end
+
+When /^creating a new attachment on the "([^"]*)" field with name "([^"]*)"$/ do |field, filename|
+  file = File.expand_path("../../supports/#{filename}", __FILE__)
+  @attachment = Rack::Test::UploadedFile.new(file, "plain/text")
+  @document.save_attachment_for(field.to_sym, @attachment)
+  @document.attachments_for(field.to_sym).should have(1).record
+end
+
+When /^deleting the attachment on the "([^"]*)" field with name "([^"]*)"$/ do |field, filename|
+  @attachment = @document.attachments_for(field.to_sym).last  
+  @document.delete_attachment_for(field,@attachment.id)
+end
+                       
+When /^updating the attachment on the "([^"]*)" field with name "([^"]*)"$/ do |field, filename|
+  @attachment = @document.attachments_for(field.to_sym).last  
+  file = File.expand_path("../../supports/#{filename}", __FILE__)
+  updated_file = Rack::Test::UploadedFile.new(file, "plain/text")
+  
+  @document.update_attachment_for(field,@attachment.id, updated_file)
+end
+# Then ##########################################################
+Then /^([^"]*) alert should be found in the inbox of the user$/ do |number|
+  @notifier = @document.notifier
+  # @current_user.inbox.messages.should have(number.to_i).record
+  # @message = @current_user.inbox.messages.last
+end                                          
+
+Then /^should regard the "([^"]*)" field$/ do |field|
+  @notifier.matched_label.should == field
+end
+
+Then /^should record the "([^"]*)" model class$/ do |model_class|
+  @notifier.model_class.should == model_class
+end
+
+Then /^should record the "([^"]*)" in the old_value$/ do |old_value|
+  @notifier.old_value.should == old_value
+end
+
+Then /^should record the "([^"]*)" in the new_value$/ do |new_value|
+  @notifier.new_value.should == new_value
+end
+
+Then /^should record the "([^"]*)" in the type$/ do |type|
+  @notifier.type.to_s.should == type
+end
+
+Then /^should record the current_user_id in the created_by$/ do
+  @notifier.created_by.to_i.should == User.current.id
+end

data/features/supports/file.txt

@@ -0,0 +1 @@
+my test

data/features/supports/initializer.rb

@@ -0,0 +1 @@
+require "#{File.dirname(__FILE__)}/../../spec/spec_helper.rb"

data/features/supports/updated_file.txt

@@ -0,0 +1 @@
+my updated test

data/features/watchlist/add_a_user_to_a_watcher.feature

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+Feature: Add a user to a watcher
+	In order to alert a user of a modified attribute value or metadata 
+	of an ActiveRecord object
+	As a user
+	I want add myself to the list of users for that attribute that will 
+	be notified when that value or metadata will be changed by someone
+                                                    
+	Background: 
+		Given an ActiveRecord object instance of 'Document'
+		And an ActiveRecord object instance of 'User'
+	
+	Scenario: creates a watcher for an attribute and add a user to its collection
+		Given a User "fg@fractalgarden.com"
+		When adding the user to the watcherslist of an attribute "name"
+		Then it should be created a new watcher for that field 
+		And added a user to the list of the watcher
+
+

data/features/watchlist/trigger_alert_on_modify.feature

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+Feature: Trigger alert on modify
+	In order to alert a user of a modified attribute value or metadata 
+	of an ActiveRecord object
+	As a user
+	I want to find a new notification in my inbox when a watcher is set 
+	on a field and a modification on it occurs
+                                                    
+	Background: 
+		Given an ActiveRecord instance of 'Document' with 'name' equals to "pippo"
+		And a User "fg@fractalgarden.com" instantiated
+	
+	Scenario: receive a new alert in the inbox when a save of a field value occurs
+		Given a watcher on the "name" field 
+		When saving a new value "pluto" on the "name" field
+		Then 1 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "pluto" in the new_value
+		And should record the "pippo" in the old_value 
+		And should record the "history_message" in the type
+		And should record the current_user_id in the created_by
+		
+	Scenario: receive a new alert in the inbox when a note of a field is added
+		Given a watcher on the "name" field 
+		When creating a new note on the "name" field with content "new note!"
+		Then 1 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "new note!" in the new_value
+		And should record the "" in the old_value 
+		And should record the "note_message" in the type
+		And should record the current_user_id in the created_by
+
+	Scenario: receive a new alert in the inbox when a note of a field is updated
+		Given a watcher on the "name" field 
+		When creating a new note on the "name" field with content "new note!"
+		And afterwards I update the note on the field "name" with content "updated note!"
+		Then 2 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "new note!" in the old_value 
+		And should record the "updated note!" in the new_value
+		And should record the "note_message" in the type
+		And should record the current_user_id in the created_by
+
+	Scenario: receive a new alert in the inbox when a note of a field is deleted
+		Given a watcher on the "name" field 
+		When creating a new note on the "name" field with content "new note!"
+		And afterwards I delete the note on the field "name"
+		Then 2 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "new note!" in the old_value 
+		And should record the "" in the new_value
+		And should record the "note_message" in the type
+
+	Scenario: receive a new alert in the inbox when a attachment of a field is created
+		Given a watcher on the "name" field 
+		When creating a new attachment on the "name" field with name "file.txt"
+		Then 1 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "file.txt" in the new_value
+		And should record the "" in the old_value
+		And should record the "attachment_message" in the type
+		And should record the current_user_id in the created_by
+
+	Scenario: receive a new alert in the inbox when a attachment of a field is updated
+		Given a watcher on the "name" field
+		When creating a new attachment on the "name" field with name "file.txt"
+		And updating the attachment on the "name" field with name "updated_file.txt"
+		Then 2 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "updated_file.txt" in the new_value
+		And should record the "file.txt" in the old_value
+		And should record the "attachment_message" in the type
+		And should record the current_user_id in the created_by
+
+	Scenario: receive a new alert in the inbox when a attachment of a field is deleted
+		Given a watcher on the "name" field 
+		When creating a new attachment on the "name" field with name "file.txt"
+		And deleting the attachment on the "name" field with name "file.txt"
+		Then 2 alert should be found in the inbox of the user 
+		And should regard the "name" field 
+		And should record the "Document" model class 
+		And should record the "" in the new_value
+		And should record the "file.txt" in the old_value
+		And should record the "attachment_message" in the type

data/lib/active_metadata/base.rb

@@ -0,0 +1,59 @@
+module ActiveMetadata
+
+  CONFIG = File.exists?('config/active_metadata.yml') ? YAML.load_file('config/active_metadata.yml')[Rails.env] : {}
+ 
+  ## Define ModelMethods
+  module Base
+    
+    require 'mongoid' if ActiveMetadata::CONFIG['persists_with'] == 'mongoid'
+    require 'mongoid_paperclip' if ActiveMetadata::CONFIG['persists_with'] == 'mongoid'
+    require 'paperclip' if ActiveMetadata::CONFIG['persists_with'] == 'active_record'
+    require "active_metadata/persistence/persistence"
+
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+      end
+    end
+
+    module Config
+
+      def acts_as_metadata *args
+        after_save :save_history
+        
+        class_variable_set("@@metadata_id_from", args.empty? ? nil : args[0][:metadata_id_from])
+
+        include ActiveMetadata::Base::InstanceMethods
+        include ActiveMetadata::Persistence   
+             
+      end
+
+    end
+
+    module InstanceMethods
+
+      def metadata_id
+        metadata_id_from = self.class.class_variable_get("@@metadata_id_from")
+        return self.id if metadata_id_from.nil?
+        receiver = self
+        metadata_id_from.each do |item|
+          receiver = receiver.send item
+        end
+        receiver.id
+      end
+      
+      def current_user_id
+        if User.respond_to?(:current) && !User.current.nil?
+            User.current.id
+        else
+          nil
+        end      
+      end  
+                
+    end # InstanceMethods
+  end
+
+end
+
+::ActiveRecord::Base.send :include, ActiveMetadata::Base
+

data/lib/active_metadata/persistence/active_record/attachment.rb

@@ -0,0 +1,42 @@
+module ActiveMetadata::Persistence::ActiveRecord::Attachment
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def save_attachment_for(field, file)      
+      attachment = Attachment.create! :document_id => metadata_id, :label => field, :attach => file, :created_by => current_user_id       
+      self.send(:send_notification, field, "", attachment.attach.original_filename, :attachment_message, current_user_id)
+    end
+
+    def attachments_for(field)
+      Attachment.all(:conditions => {:document_id => metadata_id,:label => field}, :order => "attach_updated_at DESC")
+    end
+
+    def delete_attachment_for(field,id)
+      a = Attachment.find(id)
+      filename = a.attach.original_filename
+      a.destroy      
+      self.send(:send_notification, field, filename, "", :attachment_message)
+    end
+
+    def update_attachment_for(field, id, newfile)
+      a = Attachment.find(id)
+      old_filename = a.attach.original_filename
+      a.attach = newfile
+      a.updated_by = current_user_id
+      a.save                                            
+      new_filename = a.attach.original_filename
+      
+      self.send(:send_notification, field, old_filename, new_filename, :attachment_message, current_user_id)
+    end
+
+    def has_attachments_for field
+      Attachment.count(:conditions => {:label => field, :document_id => metadata_id}) == 0 ? false : true
+    end
+
+  end
+
+end

data/lib/active_metadata/persistence/active_record/history.rb

@@ -0,0 +1,22 @@
+module ActiveMetadata::Persistence::ActiveRecord::History
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def save_history
+      self.changes.each do |key, value|
+        next if ActiveMetadata::CONFIG['history_skip_fields'].include?(key)        
+        History.create! :value => value[1],:document_id => metadata_id,:label => key.to_s, :created_by => current_user_id 
+        self.send(:send_notification, key, value[0], value[1], :history_message,current_user_id) 
+      end
+    end
+
+    def history_for field
+      History.all(:conditions => {:document_id => metadata_id,:label => field}, :order => "created_at DESC")
+    end
+
+  end
+end

data/lib/active_metadata/persistence/active_record/note.rb

@@ -0,0 +1,45 @@
+module ActiveMetadata::Persistence::ActiveRecord::Note
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    
+    def create_note_for(field, note)      
+      Note.create! :document_id => metadata_id,:label => field.to_s,:note => note, :created_by => current_user_id    
+      self.send(:send_notification, field, "", note, :note_message, current_user_id) 
+    end
+
+    def update_note(id, note)
+      n = Note.find(id)
+      old_value = n.note
+      n.update_attributes! :note => note, :updated_by => current_user_id, :updated_at => Time.now.utc
+      
+      self.send(:send_notification, n.label, old_value, note, :note_message, current_user_id)
+    end
+
+    def notes_for(field)
+      Note.all(:conditions => {:label => field, :document_id => metadata_id}, :order => "updated_at DESC" )
+    end
+
+    def note_for(field,id)
+      Note.find(id)
+    end      
+    
+    def create_notes_for(field,notes)
+      notes.each { |note| create_note_for field, note }
+    end
+
+    def delete_note_for(field,id)
+      n = Note.find(id)
+      old_value = n.note
+      n.destroy
+      self.send(:send_notification, field, old_value, "", :note_message)
+    end
+    
+    def has_notes_for field
+      Note.count(:conditions => {:label => field, :document_id => metadata_id}) == 0 ? false : true
+    end
+  end
+end

data/lib/active_metadata/persistence/active_record/watcher.rb

@@ -0,0 +1,45 @@
+module ActiveMetadata::Persistence::ActiveRecord::Watcher
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def create_watcher_for(field, owner)
+      raise RuntimeError, "The object id MUST be valued" unless self.id
+      Watcher.create! :document_id => metadata_id, :label => field, :owner_id => owner.id 
+    end                      
+
+    def watchers_for(field)
+      Watcher.all(:conditions => {:label => field, :document_id => metadata_id})   
+    end
+
+    def delete_watcher_for(field, owner)
+      Watcher.where(:document_id => metadata_id, :label => field, :owner_id => owner.id).each do |watcher|
+        watcher.destroy
+      end   
+    end    
+    
+    def is_watched_by(field,owner)
+      Watcher.where(:document_id => metadata_id, :label => field, :owner_id => owner.id).empty? ? false : true 
+    end                    
+
+    def send_notification(field, old_value, new_value, type=:default_message, created_by=nil)   
+      watchers_for(field).each { |watch| notify_changes(field, old_value, new_value, self.class.to_s, self.id, watch.owner_id, type, created_by) }
+    end
+          
+    def notifier
+      @notifier
+    end
+    
+    private
+    def notify_changes(matched_label, old_value, new_value, model_class, model_id, owner_id, type, created_by)    
+      raise "A watcher notifier class must be implemented" unless WatcherNotifier
+
+      @notifier = WatcherNotifier.new
+      @notifier.notify(matched_label.to_s, old_value, new_value, model_class, model_id,owner_id,type, created_by)                                                                               
+    end
+    
+  end
+
+end

data/lib/active_metadata/persistence/active_record.rb

@@ -0,0 +1,26 @@
+module ActiveMetadata::Persistence::ActiveRecord
+
+  require "model/active_record/note"
+  require "model/active_record/history"
+  require "model/active_record/watcher"
+  require "model/active_record/attachment"
+  
+  require "active_metadata/persistence/active_record/note"
+  require "active_metadata/persistence/active_record/history"
+  require "active_metadata/persistence/active_record/watcher"
+  require "active_metadata/persistence/active_record/attachment"
+  
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+              
+  module InstanceMethods
+    
+    include ActiveMetadata::Persistence::ActiveRecord::Note
+    include ActiveMetadata::Persistence::ActiveRecord::History
+    include ActiveMetadata::Persistence::ActiveRecord::Watcher
+    include ActiveMetadata::Persistence::ActiveRecord::Attachment
+
+  end                         
+
+end

data/lib/active_metadata/persistence/mongoid/attachment.rb

@@ -0,0 +1,45 @@
+module ActiveMetadata::Persistence::Mongoid::Attachment
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def save_attachment_for(field, file)
+      label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s)
+      counter = label.attachments.count > 0 ? label.attachments.last.counter : 0
+      attachment = Attachment.new(:attach => file, :counter => (counter + 1))
+      label.attachments << attachment
+      label.save
+      
+      self.send(:send_notification, field, "", attachment.attach.original_filename)
+    end
+
+    def attachments_for(field)
+      label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s)
+      label.attachments.desc(:attach_updated_at).to_a
+    end
+
+    def delete_attachment_for(field,id)
+      a = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s).attachments.find(id)
+      filename = a.attach.original_filename
+      a.destroy
+      
+      self.send(:send_notification, field, filename, "")
+    end
+
+    def update_attachment_for(field, id, newfile)
+      a = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s).attachments.find(id)
+      old_filename = a.attach.original_filename
+      a.attach = newfile
+      a.save                                            
+      new_filename = a.attach.original_filename
+      
+      self.send(:send_notification, field, old_filename, new_filename)
+    end
+
+  end
+
+end
+

data/lib/active_metadata/persistence/mongoid/history.rb

@@ -0,0 +1,26 @@
+module ActiveMetadata::Persistence::Mongoid::History
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def save_history
+      self.changes.each do |key, value|
+        next if ActiveMetadata::CONFIG['history_skip_fields'].include?(key)
+        
+        label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => key.to_s)
+        label.histories.create!(:value => value[1], :created_at => Time.now.utc)
+      end
+    end
+
+    def history_for field
+      meta = ActiveMeta.find_or_create_by(:document_id => metadata_id)
+      
+      label = meta.labels.find_or_create_by(:name => field.to_s)
+      label.histories.desc(:created_at).to_a
+    end
+
+  end
+end

data/lib/active_metadata/persistence/mongoid/note.rb

@@ -0,0 +1,48 @@
+module ActiveMetadata::Persistence::Mongoid::Note
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    
+    def create_note_for(field, note, created_by=nil)
+      raise RuntimeError, "The object id MUST be valued" unless self.id
+      label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s)
+      label.notes.create!(:note => note, :created_by => created_by, :created_at => Time.now.utc, :updated_at => Time.now.utc)
+                                                     
+      # BEWARE: I'm not checking the send_notification method existence
+      # this notification should be asynch
+      self.send(:send_notification, field, "", note) 
+    end
+
+    def update_note(id, note, updated_by=nil)
+      n = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => 'name').notes.find id
+      old_value = n.note
+      n.update_attributes :note => note, :updated_by => updated_by, :updated_at => Time.now.utc
+      
+      self.send(:send_notification, n.label, old_value, note)
+    end
+
+    def notes_for(field)
+      label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s)
+      label.notes.desc(:updated_at).to_a
+    end
+
+    def note_for(field,id)
+      label = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s)
+      label.notes.find(id)      
+    end      
+    
+    def create_notes_for(field,notes)
+      notes.each { |note| create_note_for field, note }
+    end
+
+    def delete_note_for(field,id)
+      n = ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field.to_s).notes.find(id)
+      old_value = n.note
+      n.destroy
+      self.send(:send_notification, field, old_value, "")
+    end
+  end
+end

data/lib/active_metadata/persistence/mongoid/watcher.rb

@@ -0,0 +1,43 @@
+module ActiveMetadata::Persistence::Mongoid::Watcher
+
+  def self.included(receiver)
+    receiver.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+    def create_watcher_for(field, owner)
+      raise RuntimeError, "The object id MUST be valued" unless self.id
+
+      label_path(field).watchers.create!(:owner_id => owner.id, :created_at => Time.now.utc, :updated_at => Time.now.utc)
+
+      owner.create_inbox unless owner.inbox # ensure that an inbox is present
+    end                      
+
+    def watchers_for(field)
+      label_path(field).watchers.asc(:created_at).to_a
+    end
+
+    def delete_watcher_for(field, owner)
+      #TODO
+    end    
+    
+    def is_watched_by(field,owner)
+      #TODO
+    end                    
+
+    # This is a callback method of the after_save of the ActiveRecord
+    # object. 
+    # TODO: It should definetly be decoupled in time from the save of
+    # the alerting system
+    def on_save_watcher_callback                          
+      self.changes.each do |field, values|
+        send_notification(field, values.first, values.last)
+      end
+    end
+
+    def send_notification(field, old_value, new_value)   
+      watchers_for(field).each { |watch| watch.notify_changes(field, old_value, new_value, self.class, self.id) }
+    end
+  end
+
+end

data/lib/active_metadata/persistence/mongoid.rb

@@ -0,0 +1,30 @@
+module ActiveMetadata::Persistence::Mongoid
+ 
+    require "active_metadata/persistence/mongoid/attachment"
+    require "active_metadata/persistence/mongoid/note"
+    require "active_metadata/persistence/mongoid/history"
+    require "active_metadata/persistence/mongoid/watcher"
+    require "model/mongoid/active_meta"
+    require "model/mongoid/label"
+    require "model/mongoid/note"
+    require "model/mongoid/history"
+    require "model/mongoid/attachment"
+    require "model/mongoid/watcher"   
+    
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+    end
+                
+    module InstanceMethods
+      
+      include ActiveMetadata::Persistence::Mongoid::Note
+      include ActiveMetadata::Persistence::Mongoid::History
+      include ActiveMetadata::Persistence::Mongoid::Attachment
+      include ActiveMetadata::Persistence::Mongoid::Watcher
+
+      def label_path(field_name)
+        ActiveMeta.find_or_create_by(:document_id => metadata_id).labels.find_or_create_by(:name => field_name.to_s)
+      end              
+
+    end                         
+end

data/lib/active_metadata/persistence/persistence.rb

@@ -0,0 +1,13 @@
+module ActiveMetadata::Persistence
+  
+  PERSISTS_WITH = ActiveMetadata::CONFIG['persists_with']
+  
+  require "active_metadata/persistence/mongoid" if PERSISTS_WITH == 'mongoid'
+  require "active_metadata/persistence/active_record" if PERSISTS_WITH == 'active_record' 
+  
+  def self.included(receiver)
+    persister = PERSISTS_WITH == 'active_record' ? ActiveMetadata::Persistence::ActiveRecord : ActiveMetadata::Persistence::Mongoid 
+    receiver.send :include, persister
+  end
+
+end

data/lib/active_metadata/railtie.rb

@@ -0,0 +1,6 @@
+require 'rails'
+class Railtie < Rails::Railtie
+  rake_tasks do
+    require_relative '../rake/task.rb'
+  end
+end