syncro 0.0.3

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+test.rb
+dump.db

data/README

@@ -0,0 +1,138 @@
+Syncro let's you synchronise Ruby classes and state between remote clients.
+Syncro also supports offline sync.
+
+You can record changes to a Ruby class, then Syncro will replay them on a remote client,
+synchronising state between the two.
+
+Syncro leaves the connection management up to you. You can use any networking library (EventMachine/TCPSockets etc).
+
+Each client is represented by a GUID. Even if your architecture isn't P2P clients, the server is 
+considered a "client", and needs a GUID too (even if that's just the string "server").
+
+Syncro is already setup to support ActiveModel compliant classes (such as ActiveRecord/SuperModel).
+For example, to synchronise a ActiveRecord class:
+
+class TestSync < ActiveRecord::Base
+  include Syncro::Model
+end
+
+If you want to use Syncro with non ActiveModel compliant classes, you need to implement the class method "sync_play",
+and create Syncro::Scriber::Scribe objects whenever the class changes - checkout Syncro::Scriber::Model and Syncro::Scriber::Observer.
+
+To synchronize a class you need to:
+  * Include Syncro::Model on that class
+  * Call the following upon connection:
+      @client = Syncro::Client.for(:client_uuid1)
+      @client.connect(connection_instance)
+      @client.sync
+  * Call the following when the connection receives data:
+      @client.receive_data(data)
+  * Call the following when the client disconnects:
+      @client.disconnect
+      
+That's it!
+
+Have a look at the example test client and server.
+
+= More information
+
+To Syncro, everything is a client - even the server. Every client is represented by a unique identifier.
+This could be a client ID, or in the case of a server a fixed string.
+
+Each client records changes to its classes. When a class changes, a 'Scribe' is created detailing that change.
+Replaying that Scribe on remote clients synchronises class state.
+
+When a client synchronises, it asks the remote client for all Scribes since the last sync. The client then replays
+the Scribes, synchronising state. The remote client then does the same. If the clients are connected, and a Scribe
+is created, the remote client is immediately notified.
+
+When clients connect for the first time, client objects are created. These record the time synchronisation happened (the last Scribe they processed).
+
+Scribes & Clients can be stored in two ways:
+  * Marshaled to disk (see SuperModel::Marshal)
+  * In Redis
+
+ActiveRecord support hasn't been added (but could be easily).
+
+You should use Redis on the server for performance reasons.
+
+= Limiting access
+
+By default, all model changes are synced with everyone. This isn't ideal for a lot of use cases - for example if a user had many pages, those pages are specific to the user and shouldn't be synced with anyone else.
+
+To limit access, you need to implement the following methods on the class.
+
+def scribe_clients
+ [authed_client_uuid1, authed_client_uuid2]
+end
+
+def self.scribe_authorized?(scribe)
+  # Check scribe.type and scribe.from_client
+  # to work out if the client is authorised to
+  # synchronise this scribe.
+end
+
+= Quick example
+
+The following is an example of using EM, SuperModel and Syncro.
+Any changes to the class "Test" will be reflected across both clients:
+
+  require "syncro"
+  require "syncro/marshal"
+  require "eventmachine"
+
+  class Test < SuperModel::Base
+    include SuperModel::Marshal::Model
+    include Syncro::Model
+  end
+
+  class MyConnection < EM::Connection
+    def connection_complete
+      @client = Syncro::Client.for(:server)
+      @client.connect(self)
+      @client.sync
+    end
+  
+    def receive_data(data)
+      puts "Received: #{data}"
+      @client.receive_data(data)
+    end
+  end
+
+  SuperModel::Marshal.path = "dump.db"
+  SuperModel::Marshal.load
+
+  at_exit {
+    SuperModel::Marshal.dump
+  }
+
+  EM.run {
+    EM.connect("0.0.0.0", 10000, MyConnection)
+  }
+  
+== Protocol
+
+Syncro uses a very simple JSON protocol. 
+Each message is a JSON hash. The only mandatory field is "type".
+{"type" => "foo", ...}
+
+Each message is preceded by a short int, representing the message size.
+For example, in Ruby:
+  data = {:type => "foo", :bar => 1}
+  message = [data.length].pack('n') + data
+
+At the moment, there are only two types of message:
+  * sync (args: from)
+  * add_scribe (args: scribe)
+  
+Have a look at app.rb for implementation details.
+
+If the messages are split up already, i.e. you don't need the binary length preceding 
+the message, you can instead use the method @client.receive_message(json_string_or_hash)
+This is particular useful for WebSocket clients.
+
+== Roadmap
+
+* A JavaScript Syncro client for web apps that have offline capabilities, and can use WebSockets to
+  sync with the server. WebSockets should be on the iPhone/iPad soon.
+* Easier protocol extensions, for things like authenticating clients (which are done by subclassing atm).

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "syncro"
+    gemspec.summary = "Sync Ruby classes between clients."
+    gemspec.email = "info@eribium.org"
+    gemspec.homepage = "http://github.com/maccman/syncro"
+    gemspec.description = "Sync Ruby classes between clients."
+    gemspec.authors = ["Alex MacCaw"]
+    gemspec.add_dependency("activesupport", ">=3.0.0.beta")
+    gemspec.add_dependency("supermodel",    ">=0.0.1")
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/examples/.gitignore

@@ -0,0 +1,2 @@
+dump_client.db
+dump_server.db

data/examples/test_client.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib syncro])
+require "eventmachine"
+require "supermodel"
+
+class Test < SuperModel::Base
+  include SuperModel::Marshal::Model
+  include Syncro::Model
+end
+
+class MyConnection < EM::Connection
+  def connection_complete
+    @client = Syncro::Client.for(:server)
+    @client.connect(self)
+    @client.sync
+  end
+  
+  def receive_data(data)
+    puts "Received: #{data}"
+    @client.receive_data(data)
+  end
+  
+  def send_data(data)
+    puts "Sending: #{data}"
+    super(data)
+  end
+  
+  def unbind
+    @client.disconnect
+  end
+end
+
+require "syncro/marshal"
+
+SuperModel::Marshal.path = "dump_client.db"
+SuperModel::Marshal.load
+
+at_exit {
+  SuperModel::Marshal.dump
+}
+
+unless $0 =~ /irb/
+  EM.run {
+    EM.connect("0.0.0.0", 10000, MyConnection)
+  }
+end

data/examples/test_server.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), *%w[.. lib syncro])
+require "eventmachine"
+require "supermodel"
+
+class Test < SuperModel::Base
+  include SuperModel::Marshal::Model
+  include Syncro::Model
+  
+  def scribe_clients
+    [:client_uuid1, :client_uuid2]
+  end
+end
+
+class MyConnection < EM::Connection
+  def post_init
+    @client = Syncro::Client.for(:client_uuid1)
+    @client.connect(self)
+    @client.sync
+  end
+  
+  def receive_data(data)
+    puts "Received: #{data}"
+    @client.receive_data(data)
+  end
+  
+  def send_data(data)
+    puts "Sending: #{data}"
+    super(data)
+  end
+  
+  def unbind
+    @client.disconnect
+  end
+end
+
+require "syncro/marshal"
+
+SuperModel::Marshal.path = "dump_server.db"
+SuperModel::Marshal.load
+
+at_exit {
+  SuperModel::Marshal.dump
+}
+
+unless $0 =~ /irb/
+  EM.run {
+    EM.start_server("0.0.0.0", 10000, MyConnection)
+  }
+end

data/lib/syncro.rb

@@ -0,0 +1,31 @@
+gem "supermodel"
+require "supermodel"
+
+gem "activesupport"
+require "active_support"
+require "active_support/core_ext/class/attribute"
+
+module Syncro
+  class SyncroError < StandardError; end
+  
+  def klasses
+    @klasses ||= []
+  end
+  module_function :klasses
+end
+
+$:.unshift(File.dirname(__FILE__))
+
+require "syncro/app"
+require "syncro/client"
+require "syncro/base"
+require "syncro/model"
+require "syncro/protocol/message"
+require "syncro/protocol/message_buffer"
+require "syncro/response"
+require "syncro/scriber"
+require "syncro/scriber/base"
+require "syncro/scriber/model"
+require "syncro/scriber/observer"
+require "syncro/scriber/scribe"
+require "syncro/scriber/scribe_observer"

data/lib/syncro/app.rb

@@ -0,0 +1,92 @@
+module Syncro
+  class App
+    attr_reader :client, :message
+    
+    def initialize(client)
+      @client = client
+    end
+    
+    def call(message)
+      @message = message
+      method   = "invoke_#{message.type}"
+      send(method) if respond_to?(method)
+    end
+    
+    def sync
+      invoke(:sync, :from => client.last_scribe_id) do |resp|
+        scribes = resp.map {|s| 
+          scribe = Scriber::Scribe.new(s)
+          scribe.from_client = client.to_s
+          scribe
+        }
+        allowed_scribes = scribes.select {|s| 
+          allowed_klasses.include?(s.klass) 
+        }
+        allowed_scribes.each {|s| s.play }
+        
+        if scribes.any?
+          client.update_attribute(
+            :last_scribe_id, 
+            scribes.last.id
+          )
+        end
+        yield if block_given?
+      end
+    end
+    
+    def add_scribe(scribe, &block)
+      invoke(
+        :add_scribe, 
+        :scribe => scribe, 
+        &block
+      )
+    end
+
+    protected    
+      def invoke_sync
+        result = begin
+          if message[:from]
+            Scriber::Scribe.since(client, message[:from])
+          else
+            Scriber::Scribe.for_client(client)
+          end
+        end
+        respond(result)
+      end
+      
+      def invoke_add_scribe
+        scribe = Scriber::Scribe.new(message[:scribe])
+        scribe.from_client = client.to_s
+        return unless allowed_klasses.include?(scribe.klass)
+        scribe.play
+        respond(true)
+        client.update_attribute(
+          :last_scribe_id, 
+          scribe.id
+        )
+      end
+    
+      def invoke_response
+        Response.call(client, message[:result])
+      end
+      
+      def allowed_klasses
+        Syncro.klasses.map(&:to_s)
+      end
+      
+      def invoke(type, hash = {}, &block)
+        message = Protocol::Message.new
+        message.type = type
+        message.merge!(hash)
+        Response.expect(client, &block)
+        client.send_message(message)
+      end
+    
+      def respond(res = nil)
+        message = Protocol::Message.new
+        message.type = :response
+        message[:result] = res
+        client.send_message(message)
+      end
+  end
+end

data/lib/syncro/base.rb

@@ -0,0 +1,8 @@
+module Syncro
+  module Base
+    def self.included(base)
+      Syncro.klasses << base
+      base.send :include, Scriber::Base
+    end
+  end
+end

data/lib/syncro/client.rb

@@ -0,0 +1,83 @@
+module Syncro
+  class Client < SuperModel::Base
+    include SuperModel::RandomID
+    
+    class << self
+      def for(uid)
+        find_or_create_by_uid(uid)
+      end
+    end
+    
+    attributes :uid, :connection, :last_scribe_id
+        
+    def connected?
+      !!self.connection
+    end
+    
+    def connect(connection)
+      self.connection = connection
+    end
+    
+    def disconnect
+    end
+    
+    def sync(&block)
+      app.sync(&block)
+    end
+    
+    def add_scribe(scribe, &block)
+      app.add_scribe(scribe, &block)
+    end
+    
+    def receive_data(data)
+      buffer << data
+      buffer.messages.each do |msg|
+        receive_message(msg)
+      end
+    end
+    
+    def receive_message(data)
+      message = begin
+        case data
+        when String
+          Protocol::Message.fromJSON(data)
+        when Protocol::Message
+          data
+        else
+          Protocol::Message.new(data)
+        end
+      end
+      app.call(message)
+    end
+    
+    def send_message(message)
+      return unless connected?
+      if connection.respond_to?(:send_message)
+        connection.send_message(message)
+      elsif connection.respond_to?(:send_data)
+        connection.send_data(message.serialize)
+      else
+        connection.write(message.serialize)
+      end
+    end
+    
+    def to_s
+      (uid || id).to_s
+    end
+          
+    def serializable_hash(options = {})
+      options[:except] ||= []
+      options[:except] << :connection
+      super(options)
+    end
+    
+    protected
+      def app
+        @app ||= App.new(self)
+      end
+    
+      def buffer
+        @buffer ||= Protocol::MessageBuffer.new
+      end
+  end
+end

data/lib/syncro/marshal.rb

@@ -0,0 +1,11 @@
+module Syncro
+  class Client
+    include SuperModel::Marshal::Model
+  end
+  
+  module Scriber
+    class Scribe
+      include SuperModel::Marshal::Model
+    end
+  end
+end

data/lib/syncro/model.rb

@@ -0,0 +1,8 @@
+module Syncro
+  module Model
+    def self.included(base)
+      base.send :include, Base
+      base.send :include, Scriber::Model
+    end
+  end
+end

data/lib/syncro/protocol/message.rb

@@ -0,0 +1,24 @@
+require "json"
+
+module Syncro
+  module Protocol
+    class Message < HashWithIndifferentAccess
+      def self.fromJSON(str)
+      	self.new(JSON.parse(str))
+      end
+
+      def type
+      	self[:type].try(:to_sym)
+      end
+      
+      def type=(sym)
+      	self[:type] = sym
+      end
+      
+      def serialize
+        data = self.to_json
+        [data.length].pack('n') + data
+      end    
+    end
+  end
+end

data/lib/syncro/protocol/message_buffer.rb

@@ -0,0 +1,50 @@
+module Syncro
+  module Protocol
+    class MessageBuffer < StringIO
+      # How much left to be read
+      def left
+        size - pos
+      end
+      
+      def back(n)
+        seek(n * -1, IO::SEEK_CUR)
+      end
+      
+      def trim
+        string.replace(read)
+      end
+      
+      def messages
+        messages = []
+        rewind
+        while !eof?
+          break unless left > 2
+          len = read_I16
+          msg = read(len)
+          if !msg || msg.length != len
+            back(2 + msg.length)
+            break
+          end
+          messages << msg
+        end
+        trim
+        wind
+        messages
+      end
+      
+      def wind
+        seek(0, IO::SEEK_END)
+      end
+      
+      private      
+        def read_I16
+          dat = read(2)
+          len, = dat.unpack('n')
+          if (len > 0x7fff)
+            len = 0 - ((len - 1) ^ 0xffff)
+          end
+          len
+        end
+    end
+  end
+end

data/lib/syncro/redis.rb

@@ -0,0 +1,2 @@
+require "syncro/redis/client"
+require "syncro/redis/scribe"

data/lib/syncro/redis/client.rb

@@ -0,0 +1,27 @@
+module Syncro
+  module Redis
+    class Syncro::Client
+      include SuperModel::Redis::Model
+      indexes :uid
+            
+      # We need to hold the current connections
+      # in memory (as they can't be serialized).
+      
+      class_attribute :connections
+      self.connections = {}
+      
+      def connection
+        self.class.connections[self.id]
+      end
+      
+      def connect(connection)
+        return unless self.id
+        self.class.connections[self.id] = connection
+      end
+      
+      def disconnect
+        self.class.connections.delete(self.id)
+      end
+    end
+  end
+end

data/lib/syncro/redis/scribe.rb

@@ -0,0 +1,38 @@
+module Syncro
+  module Redis
+    class Syncro::Scriber::Scribe
+      include SuperModel::Redis::Model
+      
+      class << self
+        def since(client, id)
+          items  = redis.zrange(redis_key(:clients, client), id, -1)
+          items += redis.zrange(redis_key(:clients, :all),   id, -1)
+          items  = from_ids(items)
+          items  = items.reject {|item|
+            item.from_client == client.to_s
+          }
+          items
+        end
+
+        def for_client(client)
+          since(client, 0)
+        end
+      end
+      
+      serialize :data, :clients
+
+      after_save :index_clients
+
+      protected
+        def index_clients
+          if clients.blank?
+            redis.zadd(self.class.redis_key(:clients, :all), id, id)
+          else
+            clients.each {|client|
+              redis.zadd(self.class.redis_key(:clients, client), id, id)
+            }
+          end
+        end
+    end
+  end
+end

data/lib/syncro/response.rb

@@ -0,0 +1,16 @@
+module Syncro
+  class Response
+    cattr_accessor :callbacks
+    self.callbacks = {}
+    
+    def self.expect(client, prok = nil, &block)
+     	self.callbacks[client] ||= []
+      self.callbacks[client] << (prok||block)
+    end
+    
+    def self.call(client, args)
+    	callback = self.callbacks[client].shift
+			callback && callback.call(args)
+    end
+  end
+end

data/lib/syncro/scriber.rb

@@ -0,0 +1,8 @@
+module Syncro
+  module Scriber        
+    def klasses
+      @klasses ||= []
+    end
+    module_function :klasses
+  end
+end

data/lib/syncro/scriber/base.rb

@@ -0,0 +1,28 @@
+module Syncro
+  module Scriber
+    module Base
+      def self.included(base)
+        Scriber.klasses << base
+        base.extend ClassMethods
+      end
+      
+      def scribe_clients
+        :all
+      end
+      
+      def scribe_create?
+        true
+      end
+
+      module ClassMethods
+        def record(type, options = {})
+          options.merge!({
+            :klass   => self, 
+            :type    => type
+          })
+          Scribe.create(options)
+        end
+      end
+    end
+  end
+end

data/lib/syncro/scriber/model.rb

@@ -0,0 +1,44 @@
+module Syncro
+  module Scriber
+    module Model
+      def self.included(base)
+        base.send :include, Base
+        base.extend ClassMethods
+        Observer.instance.add_observer!(base)
+      end
+
+      module ClassMethods
+        def scribe_play(scribe) #:nodoc:
+          return unless scribe_authorized?(scribe)
+          Observer.from(scribe.from_client) do
+            method = "scribe_play_#{scribe.type}"
+            send(method, scribe) if respond_to?(method)
+          end
+        end
+        
+        def scribe_play_create(scribe)
+          create(scribe.data)
+        end
+        
+        def scribe_play_update(scribe)
+          update(scribe.data[0], scribe.data[1])
+        end
+        
+        def scribe_play_destroy(scribe)
+          destroy(scribe.data[0])
+        end
+        
+        def scribe_authorized?(scribe)
+          true
+        end
+        
+        def scribe_options(value = nil)
+          @scribe_options = value if value
+          @scribe_options ||= {}
+          @scribe_options
+        end
+        alias_method :scribe_options=, :scribe_options
+      end
+    end
+  end
+end

data/lib/syncro/scriber/observer.rb

@@ -0,0 +1,127 @@
+module Syncro
+  module Scriber
+    class Observer
+      include Singleton
+      class_attribute :observed_methods
+      self.observed_methods = []
+      
+      class << self
+        def method_added(method)
+          return unless defined?(ActiveRecord)
+          self.observed_methods += [method] if ActiveRecord::Callbacks::CALLBACKS.include?(method.to_sym)
+        end
+        
+        def from_client
+          @from_client
+        end
+        
+        def from(client, &block)
+          @from_client = client
+          result = yield
+          @from_client = nil
+          result
+        end
+      end
+   
+      def after_create(rec)
+        rec.class.record(
+          :create, 
+          :data        => rec.attributes, 
+          :clients     => active_clients(rec),
+          :from_client => from_client
+        )
+      end
+      
+      def after_update(rec)
+        changed_to = rec.changes.inject({}) {|hash, (key, (from, to))| 
+          hash[key] = to
+          hash 
+        }
+        rec.class.record(
+          :update, 
+          :data        => [rec.id, changed_to], 
+          :clients     => active_clients(rec),
+          :from_client => from_client
+        )
+      end
+      
+      def after_destroy(rec)
+        rec.class.record(
+          :destroy, 
+          :data        => [rec.id], 
+          :clients     => active_clients(rec),
+          :from_client => from_client
+        )
+      end
+      
+      def update(observed_method, object) #:nodoc:
+        return unless respond_to?(observed_method)
+        return unless allowed?(object, observed_method)
+        # Is sending to clients disabled, or no clients specified?
+        return unless scribe_clients(object)
+        # Clients specified, but no non-disabled clients to send too
+        return if scribe_clients(object).any? && active_clients(object).empty?
+        send(observed_method, object) 
+      end
+
+      def observed_class_inherited(subclass) #:nodoc:
+        subclass.add_observer(self)
+      end
+      
+      def add_observer!(klass)
+        klass.add_observer(self)
+        
+        # For ActiveRecord
+        self.class.observed_methods.each do |method|
+          callback = :"_notify_observers_for_#{method}"
+          if (klass.instance_methods & [callback, callback.to_s]).empty?
+            klass.class_eval "def #{callback}; notify_observers(:#{method}); end"
+            klass.send(method, callback)
+          end
+        end
+      end
+      
+      protected
+        def allowed?(object, observed_method)
+          return false unless object.scribe_create?
+          
+          method = observed_method.to_s
+          method.gsub!(/before_|after_/, "")
+          
+          options = object.class.scribe_options
+          
+          options[:only]   = Array.wrap(options[:only]).map { |n| n.to_s }
+          options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+          
+          if options[:only].any?
+            return false unless options[:only].include?(method)
+          end
+          
+          if options[:except].any?
+            return false if options[:except].include?(method)
+          end
+          true
+        end
+      
+        def from_client
+          self.class.from_client
+        end
+        
+        def scribe_clients(object)
+          clients = object.scribe_clients
+          case clients
+          when :all
+            []
+          when Array
+            clients.empty? ? false : clients
+          else
+            false
+          end
+        end
+      
+        def active_clients(object)
+          scribe_clients(object) - [from_client]
+        end
+    end
+  end
+end

data/lib/syncro/scriber/scribe.rb

@@ -0,0 +1,53 @@
+module Syncro
+  module Scriber
+    class Scribe < SuperModel::Base
+      include SuperModel::RandomID
+      
+      class << self
+        def since(client, id)
+          record = find(id)
+          index  = records.index(record)
+          items  = records.slice((index + 1)..-1)
+          return [] unless items
+          items  = items.select {|item| 
+            item.clients.blank? || item.clients.include?(client.to_s) 
+          }
+          items  = items.reject {|item|
+            item.from_client == client
+          }
+          items.dup
+        rescue SuperModel::UnknownRecord
+          []
+        end
+      
+        def for_client(client)
+          items = records.values.select {|item| 
+            item.clients.blank? || item.clients.include?(client.to_s) 
+          }
+          items = items.reject {|item|
+            item.from_client == client.to_s
+          }
+          items.dup
+        end
+      end
+    
+      attributes :klass, :type, :data, :clients, :from_client
+      validates_presence_of :klass, :type
+  
+      def play
+        klass.constantize.scribe_play(self)
+      end
+    
+      def klass=(klass)
+        write_attribute(:klass, klass.to_s)
+      end
+      
+      def to_json(options = {})
+        options[:except] ||= []
+        options[:except] << :clients
+        options[:except] << :from_client
+        super(options)
+      end
+    end
+  end
+end

data/lib/syncro/scriber/scribe_observer.rb

@@ -0,0 +1,31 @@
+module Syncro
+  module Scriber
+    class ScribeObserver
+      include Singleton
+    
+      def after_create(rec)
+        if rec.clients.blank?
+          clients = Client.all.reject {|client| 
+            client.to_s == rec.from_client
+          }
+        else
+          clients = rec.clients.map {|r| Client.for(r) }
+        end
+        
+        clients.each {|c| c.add_scribe(rec) }
+      end
+    
+      def update(observed_method, object) #:nodoc:
+        send(observed_method, object) if respond_to?(observed_method)
+      end
+
+      def observed_class_inherited(subclass) #:nodoc:
+        subclass.add_observer(self)
+      end
+    end
+  end
+end
+
+Syncro::Scriber::Scribe.add_observer(
+  Syncro::Scriber::ScribeObserver.instance
+)

data/syncro.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{syncro}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex MacCaw"]
+  s.date = %q{2010-03-11}
+  s.description = %q{Sync Ruby classes between clients.}
+  s.email = %q{info@eribium.org}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "examples/.gitignore",
+     "examples/test_client.rb",
+     "examples/test_server.rb",
+     "lib/syncro.rb",
+     "lib/syncro/app.rb",
+     "lib/syncro/base.rb",
+     "lib/syncro/client.rb",
+     "lib/syncro/marshal.rb",
+     "lib/syncro/model.rb",
+     "lib/syncro/protocol/message.rb",
+     "lib/syncro/protocol/message_buffer.rb",
+     "lib/syncro/redis.rb",
+     "lib/syncro/redis/client.rb",
+     "lib/syncro/redis/scribe.rb",
+     "lib/syncro/response.rb",
+     "lib/syncro/scriber.rb",
+     "lib/syncro/scriber/base.rb",
+     "lib/syncro/scriber/model.rb",
+     "lib/syncro/scriber/observer.rb",
+     "lib/syncro/scriber/scribe.rb",
+     "lib/syncro/scriber/scribe_observer.rb",
+     "syncro.gemspec"
+  ]
+  s.homepage = %q{http://github.com/maccman/syncro}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Sync Ruby classes between clients.}
+  s.test_files = [
+    "examples/test_client.rb",
+     "examples/test_server.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+      s.add_runtime_dependency(%q<supermodel>, [">= 0.0.1"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+      s.add_dependency(%q<supermodel>, [">= 0.0.1"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.0.beta"])
+    s.add_dependency(%q<supermodel>, [">= 0.0.1"])
+  end
+end
+

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: syncro
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Alex MacCaw
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-11 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta
+        version: 3.0.0.beta
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: supermodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id002
+description: Sync Ruby classes between clients.
+email: info@eribium.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- examples/.gitignore
+- examples/test_client.rb
+- examples/test_server.rb
+- lib/syncro.rb
+- lib/syncro/app.rb
+- lib/syncro/base.rb
+- lib/syncro/client.rb
+- lib/syncro/marshal.rb
+- lib/syncro/model.rb
+- lib/syncro/protocol/message.rb
+- lib/syncro/protocol/message_buffer.rb
+- lib/syncro/redis.rb
+- lib/syncro/redis/client.rb
+- lib/syncro/redis/scribe.rb
+- lib/syncro/response.rb
+- lib/syncro/scriber.rb
+- lib/syncro/scriber/base.rb
+- lib/syncro/scriber/model.rb
+- lib/syncro/scriber/observer.rb
+- lib/syncro/scriber/scribe.rb
+- lib/syncro/scriber/scribe_observer.rb
+- syncro.gemspec
+has_rdoc: true
+homepage: http://github.com/maccman/syncro
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Sync Ruby classes between clients.
+test_files: 
+- examples/test_client.rb
+- examples/test_server.rb