rubysync 0.1.1 → 0.2.1

data/lib/ruby_sync/operation.rb

@@ -27,7 +27,7 @@ module RubySync
       self.new(:add, subject, values)
     end
     
-    def self.delete subject, values
+    def self.delete subject, values=nil
       self.new(:delete, subject, values)
     end
     
@@ -58,11 +58,11 @@ module RubySync
     
     remove_method :values=
     def values=(values)
-      @values = as_array(values)
+      @values = (values == nil)? nil : as_array(values)
     end
     
     def value
-      @values[0]
+      @values and @values[0]
     end
     
     def value= new_value

data/lib/ruby_sync/pipelines/base_pipeline.rb

@@ -40,12 +40,11 @@ module RubySync
     class BasePipeline
       
       include RubySync::Utilities
+      meta_eval {include(RubySync::Utilities)}
       
+      #add_dump_options
       attr_accessor :delay    # delay in seconds between checking connectors
       
-      array_option :dump_before, :dump_after
-      dump_before []
-      dump_after []
       
       def initialize
         @delay = 5
@@ -56,30 +55,47 @@ module RubySync
       end
       
       def self.client(connector_name, options={})
-        class_name = RubySync::Connectors::BaseConnector.class_name_for(connector_name)
+	options = HashWithIndifferentAccess.new(options)
+        connector_class = class_called(connector_name, "connector")
+	unless connector_class
+	  log.error "No connector called #connector_name}"
+	  return
+        end
         options[:name] ||= "#{self.name}(client)"
         options[:is_vault] = false
         class_def 'client' do
-          @client ||= eval(class_name).new(options)
+          @client ||= connector_class.new(options)
         end
       end
       
       def self.vault(connector_name, options={})
-        class_name = RubySync::Connectors::BaseConnector.class_name_for(connector_name)
+	options = HashWithIndifferentAccess.new(options)
+        connector_class = class_called(connector_name, "connector")
+	unless connector_class
+	  log.error "No connector called #{connector_name}"
+	  return
+        end
         options[:name] ||= "#{self.name}(vault)"
         options[:is_vault] = true
         class_def 'vault' do
           unless @vault
-            @vault = eval(class_name).new(options)
+            @vault = connector_class.new(options)
             @vault.pipeline = self
           end
           @vault
         end
       end
       
+      array_option :dump_before, :dump_after
+      dump_before HashWithIndifferentAccess.new
+      dump_after HashWithIndifferentAccess.new
 
-      def self.in_transform(&blk) event_method :in_transform,&blk; end
-      def self.out_transform(&blk) event_method :out_transform,&blk; end
+      def self.in_transform(&blk) deprecated_event_method :in_transform, :in_event_transform, &blk; end
+      def self.in_event_transform(&blk) event_method :in_event_transform,&blk; end
+      def self.in_command_transform(&blk) event_method :in_command_transform,&blk; end
+      def self.out_transform(&blk) deprecated_event_method :out_transform, :out_event_transform, &blk; end
+      def self.out_event_transform(&blk) event_method :out_event_transform,&blk; end
+      def self.out_command_transform(&blk) event_method :out_command_transform,&blk; end
       def self.in_match(&blk) event_method :in_match,&blk; end
       def self.out_match(&blk) event_method :out_match,&blk; end
       def self.in_create(&blk) event_method :in_create,&blk; end
@@ -89,14 +105,28 @@ module RubySync
 
       def self.event_method name,&blk
         define_method name do |event|
-          event.instance_eval &blk
+          event.instance_eval(&blk)
         end
       end
 
+      def self.deprecated_event_method name, replacement, &blk
+	log.warn "'#{name}' has been deprecated. Use '#{replacement}' instead."
+	event_method(replacement, &blk)
+      end
+
+
       def in_match(event)
         log.debug "Default matching rule - vault[in_place] exists?"
-        path = in_place(event)
-        vault.respond_to?('[]') and vault[path] and path
+	if vault.respond_to?('[]')
+          path = in_place(event) 
+	  if path
+	    log.debug "Checking for object at '#{path}' on vault."
+	    vault[path] and path
+	  end
+	else
+	  log.debug "Vault doesn't support random access - no match"
+	  nil
+	end
       end
       
       def out_match(event)
@@ -128,19 +158,10 @@ module RubySync
       def out_place_transform(event)
         event.target_path = out_place(event)
       end
-      
-      def perform_transform name, event, hint=""
-	      log.info "Performing #{name}"
-	      log.info event.to_yaml if dump_before.include?(name.to_sym)
-        call_if_exists name, event, hint
-        event.commit_changes
-	      log.info event.to_yaml if dump_after.include?(name.to_sym)
-        #log_progress name, event, hint
-      end
             
-      # Execute the pipeline once then return.
+      # execute the pipeline once then return.
       def run_once
-        log.info "Running #{name} pipeline once"
+        log.info "running #{name} pipeline once"
         started
         run_in_once
         run_out_once
@@ -157,26 +178,26 @@ module RubySync
         vault.stopped
       end
       
-      # Execute the in pipe once and then return
+      # execute the in pipe once and then return
       def run_in_once
         return unless allowed_in
-        log.debug "Running #{name} 'in' pipeline once"
+        log.debug "running #{name} 'in' pipeline once"
         client.once_only = true
         client.start {|event| in_handler(event)}
       end
       
-      # Execute the out pipe once and then return
+      # execute the out pipe once and then return
       def run_out_once
         return unless allowed_out
-        log.debug "Running #{name} 'out' pipeline once"
+        log.debug "running #{name} 'out' pipeline once"
         vault.once_only = true
         vault.start {|event| out_handler(event)}
       end
       
       def start
-        log.info "Starting #{name} pipeline"
+        log.info "starting #{name} pipeline"
         @running = true
-        trap("SIGINT") {self.stop}
+        trap("sigint") {self.stop}
         started
         while @running
           run_in_once
@@ -208,6 +229,8 @@ module RubySync
         log.info "Processing incoming #{event.type} event "+event.hint
         perform_transform :in_filter, event, event.hint
 
+        perform_transform :in_event_transform, event, event.hint
+            
         associated_entry = nil
         unless event.type == :disassociate
           associated_entry = vault.find_associated(event.association) if event.associated?
@@ -218,22 +241,22 @@ module RubySync
               event.association = Association.new(association_context, event.source_path)
               vault.associate event.association, match
               associated_entry = vault[match]
+            else
+              log.info "No match found for unassociated entry."
             end
           end          
         end
-            
+
         if associated_entry
           if event.type == :add
-        	  log.info "Associated entry in vault for add event. Converting to modify"
-            event.convert_to_modify
+	    log.info "Associated entry in vault for add event. Converting to modify"
+            event.convert_to_modify associated_entry, allowed_in
           end
         elsif event.type == :modify
-      	    log.info "No associated entry in vault for modify event. Converting to add"
-      	    event.convert_to_add 
+	  log.info "No associated entry in vault for modify event. Converting to add"
+	  event.convert_to_add 
         end
 
-        perform_transform :in_transform, event, event.hint
-
         case event.type
         when :add
           if in_create(event)
@@ -252,20 +275,25 @@ module RubySync
           end
         end
 
-        with_rescue("#{vault.name}: Processing command") {vault.process(event)}
+	perform_transform :in_command_transform, event, event.hint
+
+	if event.effective_operation?
+	  with_rescue("#{vault.name}: Processing command") {vault.process(event)}
+	else
+	  log.info "No change."
+	end
         log.info "---\n"
         
       end
       
-      # Called by the 'in' connector in the 'in' thread to process events generated by the client.
-      # Note: The client can't really know whether the event is an add or a modify because it doesn't store
-      # the association.
+      # Called by the 'vault' connector in the 'out' thread to process events generated by the vault.
       def out_handler(event)
         event.target = @client
         event.retrieve_association(association_context)
 
         log.info "Processing outgoing #{event.type} event "+ event.hint
         perform_transform :out_filter, event, event.hint
+        perform_transform :out_event_transform, event, event.hint
 
         associated_entry = nil
         unless event.type == :disassociate
@@ -283,16 +311,14 @@ module RubySync
             
         if associated_entry
           if event.type == :add
-        	  log.info "Associated entry in client for add event. Converting to modify"
-            event.convert_to_modify
+	    log.info "Associated entry in client for add event. Converting to modify"
+            event.convert_to_modify(associated_entry,allowed_out)
           end
         elsif event.type == :modify
-      	    log.info "No associated entry in client for modify event. Converting to add"
-      	    event.convert_to_add 
+	  log.info "No associated entry in client for modify event. Converting to add"
+	  event.convert_to_add 
         end
 
-        perform_transform :out_transform, event, event.hint
-
         case event.type
         when :add
           if out_create(event)
@@ -311,6 +337,8 @@ module RubySync
           end
         end
 
+        perform_transform :out_command_transform, event, event.hint
+
         with_rescue("#{client.name}: Processing command") {client.process(event)}
         log.info "---\n"
         
@@ -434,7 +462,7 @@ module RubySync
       
       
       def in_filter(event)
-          allowed_in == [] or event.drop_all_but_changes_to(allowed_in || [])
+	allowed_in == [] or event.drop_all_but_changes_to(allowed_in || [])
       end
 
 
@@ -450,7 +478,7 @@ module RubySync
       def allowed_out; nil; end
       
       def out_filter(event)
-          allowed_out == [] or event.drop_all_but_changes_to(allowed_out || [])
+	allowed_out == [] or event.drop_all_but_changes_to(allowed_out || [])
       end
 
 

data/lib/ruby_sync/util/utilities.rb

@@ -24,15 +24,15 @@ require 'irb'
 
 
 module Kernel    
-    # Make the log method globally available
-    def log
-      unless defined? @@log
-        @@log = Logger.new(STDOUT)
-        #@@log.level = Logger::DEBUG
-        @@log.datetime_format = "%H:%M:%S"
-      end
-      @@log
-    end    
+  # Make the log method globally available
+  def log
+    unless defined? @@log
+      @@log = Logger.new(STDOUT)
+      #@@log.level = Logger::DEBUG
+      @@log.datetime_format = "%H:%M:%S"
+    end
+    @@log
+  end    
 end
 
 class Array
@@ -41,6 +41,7 @@ class Array
   end
 end
 
+
 # Generally useful methods
 module RubySync
   module Utilities
@@ -59,7 +60,20 @@ module RubySync
         log.warn "#{text}: #{exception.message}"
         log.debug exception.backtrace.join("\n")
       end
-    end    
+    end       
+
+    def dump_before
+      []
+    end
+
+    def dump_after() []; end
+    def perform_transform name, event, hint=""
+      log.info event.to_yaml if dump_before.include?(name.to_sym)
+      log.info "performing #{name}"
+      call_if_exists name, event, hint
+      event.commit_changes
+      log.info event.to_yaml if dump_after.include?(name.to_sym)
+    end
     
     def call_if_exists(method, event, hint="")
       result = nil
@@ -92,19 +106,45 @@ module RubySync
     end
     
     def pipeline_called name
-      something_called name, "pipeline"
+      begin
+	something_called name, "pipeline"
+      rescue
+	log.error "Pipeline named '#{name}' not found."
+	nil
+      end
     end
     
     
-    def connector_called name
-      something_called name, "connector"
+    def connector_called name, message=nil
+      begin
+	something_called name, "connector"
+      rescue
+	message ||= "Connector named '#{name}' not found."
+        log.error message
+	nil
+      end
     end
 
     # Locates and returns an instance of a class for
     # the given name.
-    def something_called name, extension
-      filename = "#{name.to_s}_#{extension}"
-      eval(filename.camelize).new
+    def something_called name, extension, message=nil
+      klass = class_called(name, extension, message) and klass.new()
+    end
+
+    def class_called name, extension, message=nil
+      class_for_name(class_name_for(name, extension), message)
+    end
+      
+    def class_for_name(name, message=nil)
+      eval(name)
+    rescue
+      message ||= "Unable to find class called '#{name}'"
+      log.error message
+      nil
+    end
+
+    def class_name_for name, extension
+      "#{name.to_s}_#{extension}".camelize
     end
     
     # Ensure that path is in the search path
@@ -130,7 +170,7 @@ module RubySync
       # Keep going up until we start repeating ourselves
       while File.directory?(bp) && bp != last && bp != "/"
         return bp if File.directory?("#{bp}/pipelines") &&
-        File.directory?("#{bp}/connectors")
+	  File.directory?("#{bp}/connectors")
         last = bp
         bp = File.expand_path("#{bp}/..")
       end
@@ -163,25 +203,28 @@ module RubySync
           log.warn "!!!!!!!!!!  PROBLEM, DUMP FOLLOWS: !!!!!!!!!!!!!!"
           p op
         end
-        next if subjects and !subjects.include?(op.subject)
+	key = op.subject
+        next if subjects and !subjects.include?(key)
         case op.type
         when :add
-          if record[op.subject]
-            existing = as_array(record[op.subject])
+          if record[key]
+            existing = as_array(record[key])
             next if existing == op.values # already same so ignore
             (existing & op.values).empty? or
-            raise "Attempt to add duplicate elements to #{name}"
-            record[op.subject] =  existing + op.values
+	      raise "Attempt to add duplicate elements to #{name}"
+            record[key] =  existing + op.values
           else
-            record[op.subject] = op.values
+            record[key] = op.values
           end
         when :replace
-          record[op.subject] = op.values
+          record[key] = op.values
         when :delete
-          if value == nil || value == "" || value == []
-            record.delete(op.subject)
-          else
-            record[op.subject] -= values
+          if record[key]
+            unless op.value
+              record.delete(op.subject)
+            else
+              record[key] -= op.values
+            end
           end
         else
           raise Exception.new("Unknown operation '#{op.type}'")
@@ -214,7 +257,7 @@ module RubySync
             effective << op
           end
         when :delete
-          if [nil, "", []].include?(op.values)
+          unless op.value
             effective << op if record[op.subject]
           else
             targets = op.values & existing