rubysync 0.0.3 → 0.0.4

data/lib/ruby_sync/connectors/memory_connector.rb

@@ -15,7 +15,7 @@
 
 
 require "yaml"
-
+defined?(RubySync::Connectors::BaseConnector) or require 'ruby_sync/connectors/base_connector'
 
 module RubySync::Connectors
   class MemoryConnector < RubySync::Connectors::BaseConnector

data/lib/ruby_sync/connectors/xml_connector.rb

@@ -21,78 +21,151 @@ require 'ruby_sync'
 $VERBOSE = false
 #require 'xmlsimple'
 #$VERBOSE = true
+require 'rexml/document'
 
-
+class REXML::Document
+  
+  def entry_element_for id
+    #    root.each_element_with_attribute('id', id) do |element|
+    root.each_element("entry[@id='#{id}']") do |element|
+      return element
+    end
+    nil
+  end
+  
+end
 
 module RubySync::Connectors
   class XmlConnector < RubySync::Connectors::BaseConnector
+    
+    include REXML
 
     option :filename
 
     def each_entry
-      with_xml(:read_only=>true) do |content|
-        content.each do |entry|
-          yield entry[0], entry[1][0]
+      with_xml(:read_only=>true) do |xml|
+        xml.root.each_element("entry") do |element|
+          yield element.attribute('id').value, to_entry(element)
         end
       end
     end
     
+    
     def add id, operations
-      with_xml do |content|
-        content[id] = perform_operations(operations)
+      entry = nil
+      with_xml do |xml|
+        xml.entry_element_for(id) and raise "Element '#{id}' already exists."
+        entry = perform_operations(operations)
       end
+      self[id] = entry
       id
     end
     
     def modify id, operations
-      with_xml do |content|
-        existing = content[id] && content[id][0] || {}
-        content[id] = perform_operations(operations, existing)
+      entry = nil
+      with_xml do |xml|
+        existing_entry = to_entry(xml.entry_element_for(id))
+        entry = perform_operations(operations, existing_entry)
       end
+      self[id] = entry
       id
     end
     
     def delete id
-      with_xml do |content|
-        content.delete(id)
+      xpath = "//entry[@id='#{id}']"
+      with_xml do |xml|
+        xml.root.delete_element xpath
       end
-      id
     end
     
     def [](id)
-      value = nil
-      with_xml(:read_only=>true) do |content|
-        value = content[id] && content[id][0]
+      with_xml(:read_only=>true) do |xml|
+        element = xml.entry_element_for(id)
+        return (element)? to_entry(element) : nil
       end
-      value
     end
+    
+      
 
     def []=(id, value)
-      with_xml do |content|
-        content[id] = value 
+      with_xml do |xml|
+        new_child = to_xml(id, value)
+        if old_child = xml.entry_element_for(id)   
+          xml.root.replace_child(old_child, new_child)
+        else
+          xml.root << new_child
+        end
+      end
+    end
+
+
+    def to_xml key, entry
+      el = Element.new("entry")
+      el.add_attribute('id', key)
+      entry.each do |key, values|
+        el << attr = Element.new("attr")
+        attr.add_attribute 'name', key
+        as_array(values).each do |value|
+          value_el = Element.new('value')
+          attr << value_el.add_text(value)
+        end
       end
+      el
     end
+
+
+
     
+    def to_entry entry_element
+      entry = {}
+      if entry_element
+        entry_element.each_element("attr") do |child|
+          entry[child.attribute('name').value] = values = []
+          child.each_element("value") do |value_element|
+            values << value_element.text
+          end
+        end
+      end
+      entry
+    end
+      
     
     def self.sample_config
-          return <<END
-          #
-          # "filename" should be the full name of the file containing
-          # the xml representation of the synchronized content.
-          # You probably want to change this:
-          #
-          filename "/tmp/rubysync.xml"
-END
+      return %q(
+#
+# "filename" should be the full name of the file containing
+# the xml representation of the synchronized content.
+# You probably want to change this:
+#
+filename "/tmp/rubysync.xml"
+      )
     end    
 
-private
 
-    
+    # Should be re-entrant within a single thread but isn't
+    # thread-safe.
     def with_xml options={}
-      content = (File.exist?(filename))? content = XmlSimple.xml_in(filename) : {}
-      yield content
-      XmlSimple.xml_out(content, {'OutputFile'=>filename}) unless options[:read_only]
+      unless @with_xml_invoked
+        begin
+          @with_xml_invoked = true
+          File.exist?(filename) or File.open(filename,'w') {|file| file.write('<entries/>')}
+          File.open(filename, "r") do |file|
+            file.flock(File::LOCK_EX)
+            @xml = Document.new(file)
+            begin
+              yield @xml
+            ensure
+              File.open(filename, "w") do |out|
+                @xml.write out
+              end
+            end
+          end
+        ensure
+          @with_xml_invoked = false
+        end
+      else # this is a nested call so we don't need to read or write the file
+        yield @xml
+      end
     end
-
   end
 end

data/lib/ruby_sync/event.rb

@@ -43,6 +43,8 @@ module RubySync
   # array of RubySync::Operations describing changes to the attributes of the
   # record.
   class Event
+    
+    include RubySync::Utilities
 
     attr_accessor :type,        # delete, add, modify ...
                   :source,
@@ -93,9 +95,12 @@ module RubySync
       self.association && self.association.context && self.association.key
     end
     
+    # Reduces the operations in this event to those that will
+    # alter the target record
     def merge other
-      # TODO implement merge
-      log.warn "Event.merge not yet implemented"
+#      other.type == :add or raise "Can only merge with add events"
+#      record = perform_operations(other.payload)
+      payload = effective_operations(@payload, other)
     end
     
     # Retrieves all known values for the record affected by this event and
@@ -133,7 +138,7 @@ module RubySync
     def sets_value? subject, value=nil
       return false if @payload == nil
       @payload.reverse_each do |op|
-        return true if op.subject == subject.to_s && (value == nil || op.values == value.as_array)
+        return true if op.subject == subject.to_s && (value == nil || op.values == as_array(value))
       end
       return false
     end
@@ -141,31 +146,40 @@ 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 = subject.as_array
+      subjects = as_array(subject).map {|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 = subject.as_array.map {|s| s.to_s}
+      subjects = as_array(subject).map {|s| s.to_s}
       @uncommitted_operations = uncommitted_operations.delete_if {|op| !subjects.include?(op.subject.to_s)}
     end
     
      # Add a value to a given subject unless it already sets a value
      def add_default field_name, value
-       add_value field_name, value unless sets_value? field_name
+       add_value(field_name.to_s, value) unless sets_value? field_name.to_s
      end
      
      
      def add_value field_name, value
-       uncommitted_operations << Operation.new(:add, field_name, value.as_array)
+       uncommitted_operations << Operation.new(:add, field_name.to_s, as_array(value))
      end
      
      def set_value field_name, value
-       uncommitted_operations << Operation.new(:replace, field_name, value.as_array)
+       uncommitted_operations << Operation.new(:replace, field_name.to_s, as_array(value))
      end
 
-  
+    def values_for field_name
+      values = perform_operations @payload, {}, :subjects=>[field_name.to_s]
+      values[field_name.to_s]
+    end
+    
+    def value_for field_name
+      values = values_for field_name
+      (values)? values[0] : nil
+    end
+           
     def uncommitted_operations
       @uncommitted_operations ||= @payload || []
       return @uncommitted_operations
@@ -181,7 +195,7 @@ module RubySync
     # first.
     def append new_operations
       uncommitted_operations
-      @uncommitted_operations += new_operations.as_array
+      @uncommitted_operations += as_array(new_operations)
     end
 
     # Rollback any changes that 
@@ -195,6 +209,20 @@ module RubySync
         @uncommitted_operations = nil
       end
     end
+    
+    # Typically this will be called in the 'transform_in' and 'transform_out'
+    # blocks in a pipeline configuration.
+    def map(left, right=nil, &blk)
+      if right
+        drop_changes_to left
+        @uncommitted_operations = uncommitted_operations.map do |op|
+          (op.subject.to_s == right.to_s)? op.same_but_on(left.to_s) : op
+        end
+      elsif blk and [:add, :modify].include? @type
+        drop_changes_to left.to_s
+        uncommitted_operations << RubySync::Operation.replace(left.to_s, blk.call) 
+      end
+    end
   
   protected
 
@@ -217,7 +245,7 @@ module RubySync
     # the specified subject
     def each_operation_on subject
       return unless payload
-      subjects = subject.as_array.map {|s| s.to_s}
+      subjects = as_array(subject).map {|s| s.to_s}
       payload.each do |op|
         if subjects.include?(op.subject.to_s)
           yield(op)
@@ -231,4 +259,4 @@ module RubySync
 end
 
     
-    
+    

data/lib/ruby_sync/operation.rb

@@ -18,6 +18,8 @@ module RubySync
   # Operations that may be performed on an attribute
   class Operation
   
+  include RubySync::Utilities
+  
   attr_accessor :type, :subject, :values
   
   
@@ -40,6 +42,12 @@ module RubySync
       self.values = values
     end
   
+    def ==(o)
+      subject == o.subject &&
+      type == o.type &&
+      values == o.values
+    end
+    
     remove_method :type=
     def type=(type)
       unless [:add, :delete, :replace].include? type.to_sym
@@ -50,9 +58,17 @@ module RubySync
     
     remove_method :values=
     def values=(values)
-      @values = values.as_array
+      @values = as_array(values)
     end
     
+    def value
+      @values[0]
+    end
+    
+    def value= new_value
+      @values = new_value.as_array
+    end
+
     # Returns a duplicate of this operation but with the subject
     # changed to the specified subject 
     def same_but_on subject
@@ -79,4 +95,4 @@ module RubySync
     
     
   end
-end
+end

data/lib/ruby_sync/pipelines/base_pipeline.rb

@@ -40,7 +40,10 @@ module RubySync
       
       include RubySync::Utilities
       
+      attr_accessor :delay    # delay in seconds between checking connectors
+      
       def initialize
+        @delay = 5
       end
       
       def name
@@ -61,7 +64,11 @@ module RubySync
         options[:name] ||= "#{self.name}(vault)"
         options[:is_vault] = true
         class_def 'vault' do
-          @vault ||= eval("::" + class_name).new(options)
+          unless @vault
+            @vault = eval("::" + class_name).new(options)
+            @vault.pipeline = self
+          end
+          @vault
         end
       end
       
@@ -177,7 +184,7 @@ module RubySync
       # Override to implement some kind of matching
       def out_match event
         log.debug "Default matching rule - source path exists on client?"
-        client.respond_to?(:'[]') and client[event.source_path]
+        client.respond_to?('[]') and client[event.source_path]
         false
       end
       
@@ -216,27 +223,58 @@ module RubySync
       # end
       
       # Execute the pipeline once then return.
-      # TODO Consider making this run in and out simultaneously
       def run_once
         log.info "Running #{name} pipeline once"
+        started
         run_in_once
         run_out_once
+        stopped
+      end
+      
+      def started
+        client.started
+        vault.started
+      end
+      
+      def stopped
+        client.stopped
+        vault.stopped
       end
       
       # Execute the in pipe once and then return
       def run_in_once
-        log.info "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
       def run_out_once
-        log.info "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"
+        @running = true
+        trap("SIGINT") {self.stop}
+        started
+        while @running
+          run_in_once
+          run_out_once
+          sleep delay
+        end
+        stopped
+        log.info "#{name} stopped."
+      end
+      
+      def stop
+        log.info "#{name} stopping..."
+        @running = false
+        Thread.main.run # i thought this would wake the thread from its sleep
+        # but it seems to have no effect.
+      end
       
       # Override to process the event generated by the publisher before any other processing is done.
       # Return false to veto the event.
@@ -287,7 +325,7 @@ module RubySync
       
       def in_match event
         log.debug "Default match rule - source path exists in vault"
-        vault.respond_to?(:'[]') and vault[event.source_path]
+        vault.respond_to?('[]') and vault[event.source_path]
       end
       
       # If client_to_vault_map is defined (usually by map_client_to_vault)