rubysync 0.0.5 → 0.1.0

data/lib/ruby_sync/connectors/active_record_connector.rb

@@ -51,7 +51,6 @@ module RubySync::Connectors
         db_config_filename = File.join(rails_app_path, 'config', 'database.yml')
         db_config = YAML::load(ERB.new(IO.read(db_config_filename)).result)[rails_env]
         # Require the models
-        log.debug "Loading the models for #{self.class.name}:"
         Dir.chdir(File.join(rails_app_path,'app','models')) do
           Dir.glob('*.rb') do |filename|
             log.debug("\t#{filename}")
@@ -76,9 +75,25 @@ module RubySync::Connectors
       def self.sample_config
           return <<END
 
-    application '/path/to/a/rails/application'
-    model 'name_of_model_to_sync'
-
+    # Uncomment and adjust the following if your app is a Ruby on Rails
+    # application. It will grab the config from the RoR database.yml.
+    # application '/path/to/a/rails/application'
+    # model 'name_of_model_to_sync'
+    # rails_env 'development'   # typically development or production 
+
+    # OR
+
+    # Uncomment and adjust the following if your app is not
+    # a Ruby on Rails application (EXPERIMENTAL)
+    #
+    # db_type 'mysql'  # eg 'db2', 'mysql', 'oci', 'postgresql', 'sqlite', 'sqlserver'
+    # db_host 'localhost' # network name of db server
+    # db_name 'database_name' # Name of the database (not the table)
+    # model 'my_model'
+    # class MyModel < ActiveRecord::Base
+    #     set_table_name "users"
+    # end
+    
 END
       end
       

data/lib/ruby_sync/connectors/base_connector.rb

@@ -371,18 +371,12 @@ module RubySync::Connectors
       # Ensures that the named connector is loaded and returns its class object
       def self.class_for connector_name
         name = class_name_for connector_name
-        (name)? eval("::"+name) : nil
+        (name)? eval(name) : nil
       end
 
-      # Ensures that the named connector is loaded and returns its class name.
+      # Return the class name for a path style connector name
       def self.class_name_for connector_name
-        filename = "#{connector_name}_connector"
-        class_name = filename.camelize
-        eval "defined? #{class_name}" or
-        $".include?(filename) or
-        require filename or
-        raise Exception.new("Can't find connector '#{filename}'")
-        class_name
+        '::' + "#{connector_name}_connector".camelize
       end
 
 private

data/lib/ruby_sync/connectors/file_connector.rb

@@ -22,8 +22,8 @@ module RubySync
       out_extension     ".out"
       
       def started
-        ensure_dir_exists in_path
-        ensure_dir_exists out_path
+        defined? in_path and ensure_dir_exists in_path
+        defined? out_path and ensure_dir_exists out_path
       end
       
       def each_change(&blk)

data/lib/ruby_sync/event.rb

@@ -46,8 +46,9 @@ module RubySync
     
     include RubySync::Utilities
 
-    attr_accessor :type,        # delete, add, modify ...
+    attr_accessor :type,        # :delete, :add, :modify ...
                   :source,
+                  :target,
                   :payload,
                   :source_path,
                   :target_path,
@@ -145,14 +146,14 @@ module RubySync
     
     # Remove any operations from the payload that affect fields with the given key or
     # keys (key can be a single field name or an array of field names).
-    def drop_changes_to subject
-      subjects = as_array(subject).map {|s| s.to_s}
+    def drop_changes_to *subjects
+      subjects = subjects.flatten.collect {|s| s.to_s}
       uncommitted_operations
       @uncommitted_operations = @uncommitted_operations.delete_if {|op| subjects.include? op.subject }
     end
 
-    def drop_all_but_changes_to subject
-      subjects = as_array(subject).map {|s| s.to_s}
+    def drop_all_but_changes_to *subjects
+      subjects = subjects.flatten.collect {|s| s.to_s}
       @uncommitted_operations = uncommitted_operations.delete_if {|op| !subjects.include?(op.subject.to_s)}
     end
     
@@ -170,15 +171,17 @@ module RubySync
        uncommitted_operations << Operation.new(:replace, field_name.to_s, as_array(value))
      end
 
-    def values_for field_name
+    def values_for field_name, default=[]
       values = perform_operations @payload, {}, :subjects=>[field_name.to_s]
-      values[field_name.to_s]
+      values[field_name.to_s] || default
     end
+    alias_method :values_of, :values_for 
     
-    def value_for field_name
+    def value_for field_name, default=''
       values = values_for field_name
-      (values)? values[0] : nil
+      values[0] || default
     end
+    alias_method :value_of, :value_for 
            
     def uncommitted_operations
       @uncommitted_operations ||= @payload || []
@@ -223,6 +226,10 @@ module RubySync
         uncommitted_operations << RubySync::Operation.replace(left.to_s, blk.call) 
       end
     end
+    
+    def place(&blk)
+      self.target_path = blk.call
+    end
   
   protected
 

data/lib/ruby_sync/pipelines/base_pipeline.rb

@@ -13,11 +13,12 @@
 # You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
 # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 
-lib_path = File.dirname(__FILE__) + '/../..'
-$:.unshift lib_path unless $:.include?(lib_path) || $:.include?(File.expand_path(lib_path))
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift lib_path unless $:.include?(lib_path)
 
 require 'active_support'
 require 'ruby_sync/util/metaid'
+require 'ruby_sync/util/utilities'
 require 'yaml'
 
 
@@ -42,6 +43,10 @@ module RubySync
       
       attr_accessor :delay    # delay in seconds between checking connectors
       
+      array_option :dump_before, :dump_after
+      dump_before []
+      dump_after []
+      
       def initialize
         @delay = 5
       end
@@ -55,7 +60,7 @@ module RubySync
         options[:name] ||= "#{self.name}(client)"
         options[:is_vault] = false
         class_def 'client' do
-          @client ||= eval("::#{class_name}").new(options)
+          @client ||= eval(class_name).new(options)
         end
       end
       
@@ -65,163 +70,72 @@ module RubySync
         options[:is_vault] = true
         class_def 'vault' do
           unless @vault
-            @vault = eval("::" + class_name).new(options)
+            @vault = eval(class_name).new(options)
             @vault.pipeline = self
           end
           @vault
         end
       end
       
-      def self.map_client_to_vault mappings
-        remove_method :client_to_vault_map if method_defined? :client_to_vault_map
-        class_def 'client_to_vault_map' do
-          unless @client_to_vault_map
-            @client_to_vault_map = {}
-            mappings.each {|k,v| @client_to_vault_map[k.to_s] = v.to_s}
-          end
-          @client_to_vault_map
-        end
-        unless method_defined? :vault_to_client_map
-          class_def 'vault_to_client_map' do
-            @vault_to_client_map ||= client_to_vault_map.invert
-          end
-        end
-      end
-      
-      def self.map_vault_to_client mappings
-        remove_method :vault_to_client_map if method_defined? :vault_to_client_map
-        class_def 'vault_to_client_map' do
-          unless @vault_to_client_map
-            @vault_to_client_map = {}
-            mappings.each {|k,v| @vault_to_client_map[k.to_s] = v.to_s}
-          end
-          @vault_to_client_map
-        end
-        unless method_defined? :client_to_vault_map
-          class_def 'client_to_vault_map' do
-            @client_to_vault_map ||= vault_to_client_map.invert
-          end
-        end
-      end
-      
-      def self.out_transform &blk
-        define_method :out_transform do |event|
-          event.meta_def :transform, &blk
-          event.transform
-        end
-      end
-      
-      def self.in_transform &blk
-        define_method :in_transform do |event|
-          event.meta_def :transform, &blk
-          event.transform
-        end
-      end
-      
-      
-      # Called by the identity-vault connector in the 'out' thread to process events generated
-      # by the identity vault.
-      def out_handler(event)
 
-        event.retrieve_association(association_context)
-        event.convert_to_modify if event.associated? and event.type == :add
-        
-        hint = " (#{vault.name} => #{client.name})"
-        log.info "Processing out-going #{event.type} event #{hint}"
-        log.info YAML.dump(event)
-        return unless out_event_filter event
-        
-        # Remove unwanted attributes
-        perform_transform :out_filter, event
+      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_match(&blk) event_method :in_match_if,&blk; end
+      def self.out_match(&blk) event_method :out_match_if,&blk; end
+      def self.in_create_if(&blk) event_method :in_create_if,&blk; end
+      def self.out_create_if(&blk) event_method :out_create_if,&blk; end
 
-        unless event.associated?
-          if [:delete, :remove_association].include? event.type
-            log.info "#{name}: No action for #{event.type} of unassociated entry"
-            log.info YAML.dump(event)
-            return
-          end
+      def self.event_method name,&blk
+        define_method name do |event|
+          event.instance_eval &blk
         end
+      end
 
-        if event.type == :modify
-          unless event.associated? and client.has_entry_for_key?(event.association.key)
-            event.convert_to_add
-          end
-        end
+      def self.in_place(&blk) place :in, &blk; end
+      def self.out_place(&blk) place :out, &blk; end
 
-        if event.type == :add
-          match = out_match(event) 
-          log.info "Attempting to match"
-          if match # exactly one event record on the client matched
-            log.info "Match found, merging"
-            event.merge(match)
-            association = Association.new(self.association_context, match.src_path)
-            vault.associate asssociation, event.source_path
-            return
-          end
-          log.info "No match found, creating"
-          return unless out_create(event)
-          perform_transform :out_place, event
-        end
-        
-        perform_transform :out_map_schema, event
-        perform_transform :out_transform, event
-        association_key = nil
-        with_rescue("#{client.name}: Processing command") do
-          association_key = client.process(event)
-        end
-        if association_key
-          association = Association.new(association_context, association_key)
-          with_rescue("#{client.name}: Storing association #{association} in vault") do
-            vault.associate(association, event.source_path)
-          end
+      def self.place direction, &blk
+        define_method "#{direction}_place" do |event|
+          event.target_path = event.instance_eval &blk
         end
       end
       
-      # Override to map schema from vault namespace to client namespace
-      # def out_map_schema event
-      # end
       
       # Override to implement some kind of matching
-      def out_match event
+      def default_match event
         log.debug "Default matching rule - source path exists on client?"
-        client.respond_to?('[]') and client[event.source_path]
-        false
+        event.target.respond_to?('[]') and event.target[event.source_path]
       end
+      alias_method :in_match, :default_match
+      alias_method :out_match, :default_match
       
       # Override to restrict creation on the client
-      def out_create event
+      def default_create event
         log.debug "Create allowed through default rule"
         true
       end
+      alias_method :in_create, :default_create
+      alias_method :out_create, :default_create
       
-      # Override to restrict creation on the vault
-      def in_create event
-        log.debug "Create allowed through default rule"
-        true
-      end
       
       # Override to modify the target path for creation on the client
-      def out_place(event)
+      def default_place(event)
         log.debug "Default placement rule target_path = source_path"
         event.target_path = event.source_path
       end
+      alias_method :in_place, :default_place
+      alias_method :out_place, :default_place
       
-      # Override to modify the target path for creation in the vault
-      def in_place(event)
-        log.debug "Default placement rule target_path = source_path"
-        event.target_path = event.source_path
-      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_progress name, event, hint
+	      log.info event.to_yaml if dump_after.include?(name.to_sym)
+        #log_progress name, event, hint
       end
-      
-      # Transform the out-going event before the client receives it
-      # def out_transform(event)
-      # end
-      
+            
       # Execute the pipeline once then return.
       def run_once
         log.info "Running #{name} pipeline once"
@@ -243,6 +157,7 @@ module RubySync
       
       # Execute the in pipe once and then return
       def run_in_once
+        return unless allowed_in
         log.debug "Running #{name} 'in' pipeline once"
         client.once_only = true
         client.start {|event| in_handler(event)}
@@ -250,6 +165,7 @@ module RubySync
       
       # Execute the out pipe once and then return
       def run_out_once
+        return unless allowed_out
         log.debug "Running #{name} 'out' pipeline once"
         vault.once_only = true
         vault.start {|event| out_handler(event)}
@@ -282,51 +198,127 @@ module RubySync
       
       # Called by the 'in' connector in the 'in' thread to process events generated by the client.
       def in_handler(event)
-        event.retrieve_association(association_context)        
+        event.target = @vault
+        event.retrieve_association(association_context)
 
-        hint = " (#{client.name} => #{vault.name})"
-        log.info "Processing incoming #{event.type} event"+hint
-        log.info YAML.dump(event)
-        perform_transform :in_map_schema, event, hint
-        perform_transform :in_transform, event, hint
+        hint = "(#{client.name} => #{vault.name}) #{event.source_path}"
+        log.info "Processing incoming #{event.type} event "+hint
         perform_transform :in_filter, event, hint
         
         # The client can't really know whether its an add or a modify because it doesn't store
         # the association.
         if event.type == :modify
-          event.convert_to_add unless event.associated? and vault.find_associated(event.association)
+          unless event.associated? and vault.find_associated(event.association)
+	    log.info "No associated entry in vault for modify event. Converting to add"
+	    event.convert_to_add
+	  end
         elsif event.type == :add and event.associated? and vault.find_associated(event.association)
+	  log.info "Associated entry in vault for add event. Converting to modify"
           event.convert_to_modify
         end
+
+        perform_transform :in_transform, event, hint
+
         
+	      # todo: Maybe we should merge any add or modify that is associated or matched
         if event.type == :add
-          match = in_match(event) # exactly one event record in the vault matched
+          match = in_match(event)
           if match
+	    log.info "Matching record found in vault. Merging."
             event.merge(match)
-            return
+            log.info "---\n"; return
           end
           
           if in_create(event)
             perform_transform :in_place, event, hint
+	    log.info "Create on vault allowed. Placing at #{event.target_path}"
           else
-            return
+	    log.info "Create rule disallowed creation"
+            log.info "---\n"; return
           end
         end
-        
+
         with_rescue("#{vault.name}: Processing command") {vault.process(event)}
+        log.info "---\n"
         
       end
       
+      
+          # Called by the identity-vault connector in the 'out' thread to process events generated
+          # by the identity vault.
+          def out_handler(event)
+            event.target = @client
+            event.retrieve_association(association_context)
+            event.convert_to_modify if event.associated? and event.type == :add
+
+            hint = "(path=#{event.source_path} #{vault.name} => #{client.name})"
+            log.info "Processing out-going #{event.type} event #{hint}"
+            #log.info YAML.dump(event)
+            unless out_event_filter event
+    	  log.info "Disallowed by out_event_filter"
+              log.info "---\n"; return
+    	end
+
+            # Remove unwanted attributes
+            perform_transform :out_filter, event
+
+            unless event.associated?
+    	  log.info "no association"
+              if [:delete, :remove_association].include? event.type
+                log.info "#{name}: No action for #{event.type} of unassociated entry"
+                log.info "---\n"; return
+              end
+            end
+
+            if event.type == :modify
+              unless event.associated? and client.has_entry_for_key?(event.association.key)
+    	  log.info "Can't find associated client record so converting modify to add"
+                event.convert_to_add
+              end
+            end
+
+            if event.type == :add
+              match = out_match(event) 
+              log.info "Attempting to match"
+              if match # exactly one event record on the client matched
+                log.info "Match found, merging"
+                event.merge(match)
+                association = Association.new(self.association_context, match.source_path)
+                vault.associate asssociation, event.source_path
+                log.info "---\n"; return
+              end
+              log.info "No match found, creating"
+              unless out_create(event)
+    	    log.info "Creation denied by create rule"
+                log.info "---\n"; return
+    	  end
+              perform_transform :out_place, event
+    	  log.info "Placing new entry at #{event.target_path}"
+            end
+
+            perform_transform :out_transform, event
+            association_key = nil
+            with_rescue("#{client.name}: Processing command") do
+              association_key = client.process(event)
+            end
+            if association_key
+              association = Association.new(association_context, association_key)
+              with_rescue("#{client.name}: Storing association #{association} in vault") do
+                vault.associate(association, event.source_path)
+              end
+    	else
+    	  log.info "Client didn't return an association key"
+            end
+          end
+      
+      
+      
       # The context for all association keys used by this pipeline.
       # By default, defer to the client
       def association_context
         @client.association_context
       end
-      
-      def in_match event
-        log.debug "Default match rule - source path exists in vault"
-        vault.respond_to?('[]') and vault[event.source_path]
-      end
+
       
       # If client_to_vault_map is defined (usually by map_client_to_vault)
       # then fix up the contents of the payload to refer to the fields by
@@ -345,15 +337,6 @@ module RubySync
           op.subject = map[op.subject] || op.subject if op.subject
         end
       end
-        
-      
-      
-      
-      # Override to perform whatever transformation on the event is required
-      #def in_transform(event); event; end
-      
-      # Convert fields in the incoming event to those used by the identity vault
-      #def in_map_schema(event); end
       
       # Specify which fields will be allowed through the incoming filter
       # If nil (the default), all fields are allowed. 
@@ -366,14 +349,9 @@ module RubySync
       # default allowed_in in case allow_in doesn't get called
       def allowed_in; nil; end
       
-      # Default method for allowed_in. Override by calling allow_in
-      #def allowed_in; false; end
+      
       def in_filter(event)
-        if allowed_in
-          event.drop_all_but_changes_to allowed_in
-        else
-          event
-        end
+          allowed_in == [] or event.drop_all_but_changes_to(allowed_in || [])
       end
 
 
@@ -388,17 +366,12 @@ module RubySync
       # default allowed_out in case allow_out doesn't get called
       def allowed_out; nil; end
       
-      # Default method for allowed_out. Override by calling allow_in
-      #def allowed_out; false; end
       def out_filter(event)
-        if allowed_out
-          event.drop_all_but_changes_to allowed_out
-        else
-          event
-        end
+          allowed_out == [] or event.drop_all_but_changes_to(allowed_out || [])
       end
 
 
+
     end
   end
 end

data/lib/ruby_sync/util/utilities.rb

@@ -13,22 +13,17 @@
 # You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
 # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift lib_path unless $:.include?(lib_path)
 
 require 'fileutils'
+require 'rubygems'
+require 'active_support'
 require 'irb'
 
 
-class ::File
-  def self.delete_if_exists(files)
-    files.kind_of?(Array) or files = [files]
-    files.each do |file|
-      File.delete(file) if File.exist?(file)
-    end
-  end
-end
-
-class Object    
 
+module Kernel    
     # Make the log method globally available
     def log
       unless defined? @@log
@@ -39,7 +34,12 @@ class Object
       @@log
     end    
 end
-    
+
+class Array
+  def to_ruby
+    map {|f| "'#{f}'"}.join(', ')    
+  end
+end
 
 # Generally useful methods
 module RubySync
@@ -104,7 +104,6 @@ module RubySync
     # the given name.
     def something_called name, extension
       filename = "#{name.to_s}_#{extension}"
-      $".include?(filename) or require filename or return nil
       eval(filename.camelize).new
     end
     
@@ -115,8 +114,8 @@ module RubySync
       $:.unshift path unless $:.include?(path)
     end
     
-    # Return the base_path 
-    def base_path
+    # Return the base_path
+    ::Kernel.send :define_method, :base_path do
       @@base_path = find_base_path unless @@base_path
       @@base_path
     end
@@ -125,7 +124,7 @@ module RubySync
     # all of it's ancestors until it finds one that looks like a rubysync configuration
     # directory.
     # Returns false if no suitable directory was found
-    def find_base_path
+    ::Kernel.send :define_method, :find_base_path do
       bp = File.expand_path(".")
       last = nil
       # Keep going up until we start repeating ourselves
@@ -138,12 +137,6 @@ module RubySync
       return false
     end
        
-    # Make and instance method _name_ that returns the value set by the
-    # class method _name_.
-    # def self.class_option name
-    #   self.class_eval "def #{name}() self.class.instance_variable_get :#{name}; end"
-    #   self.instance_eval "def #{name}(value) @#{name}=value; end"
-    # end
     
     def get_preference(name, file_name=nil)
       class_name ||= get_preference_file