riaktor 0.0.1 → 0.0.2

data/History.txt

@@ -1,4 +1,10 @@
-=== 0.0.1 2010-03-15
+=== 0.0.1 2010-03-18
 
 * 1 major enhancement:
   * Initial release
+
+=== 0.0.2 2010-03-18
+
+* 1 major enhancement:
+  * Fixed the Manfiest file to include everything
+  * Escape slashes in bucket and key names

data/Manifest.txt

@@ -1,9 +1,21 @@
 History.txt
+lib/riaktor/client.rb
+lib/riaktor/document/association.rb
+lib/riaktor/document/associations.rb
+lib/riaktor/document/attribute.rb
+lib/riaktor/document/attributes.rb
+lib/riaktor/document/base.rb
+lib/riaktor/document/index.rb
+lib/riaktor/document/indexes.rb
+lib/riaktor/document.rb
+lib/riaktor/r_object/link.rb
+lib/riaktor/r_object/persistence.rb
+lib/riaktor/r_object.rb
+lib/riaktor.rb
 Manifest.txt
 PostInstall.txt
-README.rdoc
 Rakefile
-lib/riaktor.rb
+README.rdoc
 script/console
 script/destroy
 script/generate

data/lib/riaktor/client.rb

@@ -0,0 +1,137 @@
+module Riaktor
+  class Client
+    class MissingOperationKey < RuntimeError; end
+    
+    def self.config
+      @config ||= { :host => "127.0.0.1", :port => 8098, :prefix => 'riak' }
+    end
+
+    def self.config=(hash)
+      @config = hash
+    end
+    
+    def self.client_id
+      Thread.current[:riaktor_client_id] ||=UUIDTools::UUID.random_create.to_s
+    end
+
+    def self.client_id=(val)
+      Thread.current[:riaktor_client_id] = val
+    end
+
+    def self.max_concurrency
+      @max_concurrency ||= 25
+    end
+
+    def self.max_concurrency=(val)
+      @max_concurrency = val
+    end
+    
+    def self.build_url(bucket,key=nil)
+      url = []
+      url << "http://#{self.config[:host]}:#{self.config[:port]}"
+      url << self.config[:prefix]
+      url << URI.escape(bucket).gsub("/", "%2F")
+      url << URI.escape(key).gsub("/", "%2F") if key
+      url.join("/")
+    end
+    
+    def self.bucket_props(bucket,params={})
+      params[:keys] ||= false
+      response = Typhoeus::Request.get(self.build_url(bucket), :params => params)
+      Yajl::Parser.parse(response.body)
+    end
+    
+    def self.set_bucket_props(bucket, props, params={})
+      body = Yajl::Encoder.encode(props)
+      response = Typhoeus::Request.put(self.build_url(bucket),
+        :params => params, :headers => { "Content-Type" => "application/json" }, :body => body)
+      response.code == 204
+    end
+    
+    def self.put(op)
+      self.put_many([op])[[op["bucket"],op["key"]]]
+    end
+    
+    def self.put_many(operations)
+      operations.each do |operation|
+        operation['bucket']  ||  raise(MissingOperationKey, "bucket")
+        operation['key']     ||  raise(MissingOperationKey, "key")
+        operation['value']   ||= ""
+        operation['headers'] ||= {}
+        operation['params']  ||= {}
+      end
+      results = {}
+      hydra = Typhoeus::Hydra.new(:max_concurrency => self.max_concurrency)
+      operations.each do |op|
+        op['params']["r"]  ||= 2
+        op['params']["w"]  ||= 2
+        op['params']["dw"] ||= 0
+        op['params']["returnbody"] ||= true
+        op['headers']["Content-Type"]    ||= "text/plain"
+        op['headers']["X-Riak-ClientId"] ||= self.client_id
+        request = Typhoeus::Request.new(self.build_url(op['bucket'],op['key']),
+          :method => :put, :headers => op['headers'], :params => op['params'], :body => op['value'].to_s)
+        request.on_complete do |response|
+          results[[op["bucket"],op["key"]]] = { "headers" => response.headers_hash, 
+            "body" => response.body, "code" => response.code }
+        end
+        hydra.queue request
+      end # operations.each
+      hydra.run; results
+    end # self.put_many
+    
+    def self.get(op)
+      self.get_many([op])[[op["bucket"],op["key"]]]
+    end
+    
+    def self.get_many(operations)
+      operations.each do |operation|
+        operation['bucket']  ||  raise(MissingOperationKey, "bucket")
+        operation['key']     ||  raise(MissingOperationKey, "key")
+        operation['headers'] ||= {}
+        operation['params']  ||= {}
+      end
+      results = {}
+      hydra = Typhoeus::Hydra.new(:max_concurrency => self.max_concurrency)
+      operations.each do |op|
+        op['params']["r"]  ||= 2
+        op['headers']["Content-Type"]    ||= "text/plain"
+        op['headers']["X-Riak-ClientId"] ||= self.client_id
+        request = Typhoeus::Request.new(self.build_url(op['bucket'],op['key']),
+          :method => :get, :headers => op['headers'], :params => op['params'])
+        request.on_complete do |response|
+          results[[op["bucket"], op["key"]]] = { "headers" => response.headers_hash, 
+            "body" => response.body, "code" => response.code }
+        end
+        hydra.queue request
+      end # operations.each
+      hydra.run; results
+    end # self.get_many
+    
+    def self.delete(op)
+      self.delete_many([op])[[op["bucket"],op["key"]]]
+    end
+    
+    def self.delete_many(operations)
+      operations.each do |operation|
+        operation['bucket']  ||  raise(MissingOperationKey, "bucket")
+        operation['key']     ||  raise(MissingOperationKey, "key")
+        operation['headers'] ||= {}
+        operation['params']  ||= {}
+      end
+      results = {}
+      hydra = Typhoeus::Hydra.new(:max_concurrency => self.max_concurrency)
+      operations.each do |op|
+        op['headers']["X-Riak-ClientId"] ||= self.client_id
+        request = Typhoeus::Request.new(self.build_url(op['bucket'],op['key']),
+          :method => :delete, :headers => op['headers'], :params => op['params'])
+        request.on_complete do |response|
+          results[[op["bucket"], op["key"]]] = { "headers" => response.headers_hash, 
+            "body" => response.body, "code" => response.code }
+        end
+        hydra.queue request
+      end # operations.each
+      hydra.run; results
+    end # self.delete_many
+  end # Client
+end

data/lib/riaktor/document/association.rb

@@ -0,0 +1,123 @@
+module Riaktor
+  module Document
+    class Association
+      attr_accessor :name, :opts, :parent
+      
+      def initialize(name, opts, parent)
+        raise(ArgumentError, "missing or invalid name") if name.blank?
+        raise(ArgumentError, "missing or invalid option :class") if opts.blank? or opts[:class].blank?
+        raise(ArgumentError, "missing or invalid parent") if parent.blank?
+        @name = name
+        @opts = opts
+        @parent = parent
+      end
+      
+      def klass
+        @klass ||= eval(opts[:class].to_s.camelize)
+      end
+      
+      def reload
+        @links = nil
+        @members = nil
+        @sort_index = nil
+        @include = nil
+        @cached_doc = nil
+      end
+      
+      def changed?
+        @changed == true
+      end
+      
+      def links
+        @links ||= begin
+          (@parent.links || []).select { |l| l.tag.to_s == @name.to_s }
+        end
+      end
+      
+      def include?(key_or_doc)
+        @include ||= {}
+        @include[key_or_doc] ||= begin
+          if key_or_doc.is_a?(String)
+            links.any? { |l| l.key == key_or_doc }
+          else
+            links.any? { |l| l.key == key_or_doc.key }
+          end
+        end
+      end
+      
+      def members(from=0,to=-1)
+        @members ||= {}
+        @members[[from..to]] ||= begin
+          if links.empty?
+            []
+          else
+            if range = links[from..to] and !range.empty?
+              found = range.collect do |link|
+                cached_doc(link.key) || link.key
+              end
+              uncached = found.select { |f| f.is_a?(String) }
+              unless uncached.empty?
+                klass.find_many(uncached).each do |key,doc|
+                  cache_doc(key,doc)
+                  found[found.index(doc.key)] = doc
+                end
+              end
+              found.sort! { |x,y| sort_index.index(x.key) <=> sort_index.index(y.key) }
+            else
+              []
+            end
+          end
+        end
+      end
+      
+      def <<(doc)
+        @changed = true
+        unless doc.class.to_s == klass.to_s
+          raise(ArgumentError, "invalid object class: #{doc.class.to_s}")
+        end
+        return true if members.include?(doc)
+        link = Riaktor::RObject::Link.new(doc.bucket, doc.key, @name.to_s)
+        @parent.links << link
+        reload
+        true
+      end
+      
+      def remove(doc)
+        @changed = true
+        @parent.links.reject! { |l| l.bucket == doc.bucket && l.key == doc.key }
+        reload
+        true
+      end
+      
+      def save
+        if res = @parent.save
+          @changed = false
+        end; res
+      end
+      
+      protected
+      
+      def cached_doc(key)
+        (@cached_doc || {})[key]
+      end
+      
+      def cache_doc(key,doc)
+        @cached_doc ||= {}
+        @cached_doc[key] = doc
+      end
+      
+      def sort_index
+        @sort_index ||= links.collect { |l| l.key }
+      end
+      
+      def add_to_sort_index(key)
+        sort_index
+        @sort_index << key unless @sort_index.include?(key)
+      end
+      
+      def remove_from_sort_index(key)
+        sort_index && @sort_index.delete(key)
+      end
+    end # Attribute
+  end # Document
+end # Riaktor

data/lib/riaktor/document/associations.rb

@@ -0,0 +1,34 @@
+require "#{File.dirname(__FILE__)}/association"
+
+module Riaktor
+  module Document
+    module Associations
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def defined_associations
+          @defined_associations || {}
+        end
+        
+        def association(name,opts={})
+          raise(ArgumentError, "missing key :class") unless opts[:class]
+          @defined_associations ||= {}
+          @defined_associations[name] = opts
+          define_method("#{name}") do
+            @associations ||= {}
+            @associations[name] ||= Association.new(name,opts,self)
+          end # define_method
+        end # def association
+      end # ClassMethods
+      
+      module InstanceMethods
+        def any_associations_changed?
+          (@associations || {}).any? { |k,v| v.changed? }
+        end
+      end
+    end # Attributes
+  end # Document
+end # Riaktor

data/lib/riaktor/document/attribute.rb

@@ -0,0 +1,13 @@
+module Riaktor
+  module Document
+    class Attribute < RObject
+      attr_accessor :parent
+      
+      def save(opts={})
+        if self.parent && self.parent.valid?
+          super(opts)
+        end
+      end
+    end # Attribute
+  end # Document
+end # Riaktor

data/lib/riaktor/document/attributes.rb

@@ -0,0 +1,79 @@
+require "#{File.dirname(__FILE__)}/attribute"
+
+module Riaktor
+  module Document
+    module Attributes
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def defined_attributes
+          @defined_attributes || {}
+        end
+        
+        def attribute(name,opts={})
+          @defined_attributes ||= {}
+          @defined_attributes[name] = opts
+          define_method("#{name}") do
+            load_attributes && @attributes[name]
+          end # define_method
+        end # def attribute
+      end # ClassMethods
+      
+      module InstanceMethods        
+        def key_for_attribute(name)
+          [self.key, "attribute", name].join("--")
+        end
+        
+        def attributes_key_to_name_map
+          @attributes_key_to_name_map ||= begin
+            map = {}
+            self.class.defined_attributes.each do |name, opts|
+              map[key_for_attribute(name)] = name
+            end; map
+          end
+        end
+        
+        def any_attributes_in_conflict?
+          load_attributes
+          @attributes.each do |name, attrib|
+            return true if attrib.in_conflict?
+          end; false
+        end
+        
+        def load_attributes(force=false)
+          return true if @attributes and !force
+          @attributes = {}
+          return true if attributes_key_to_name_map.keys.empty?
+          results = Riaktor::Document::Attribute.find_many(
+            attributes_key_to_name_map.keys, :bucket => self.bucket)
+          results.each do |att_key, doc|
+            doc ||= Riaktor::Document::Attribute.new(:key => att_key, :bucket => self.bucket, :new => true)
+            doc.parent = self
+            name = attributes_key_to_name_map[att_key]
+            @attributes[name] = doc
+          end
+          @attributes
+        end # load_attributes
+        
+        def save_attributes
+          return true unless @attributes
+          attributes_key_to_name_map.each do |att_key, att_name|
+            if attrib = @attributes[att_name]
+              attrib.save
+            end
+          end; true
+        end # save_attributes
+        
+        def destroy_attributes
+          load_attributes
+          @attributes.each do |name, attrib|
+            attrib.destroy unless attrib.new_record?
+          end; true
+        end # destroy_attributes
+      end # InstanceMethods
+    end # Attributes
+  end # Document
+end # Riaktor

data/lib/riaktor/document/base.rb

@@ -0,0 +1,124 @@
+require "#{File.dirname(__FILE__)}/attributes"
+require "#{File.dirname(__FILE__)}/associations"
+require "#{File.dirname(__FILE__)}/indexes"
+
+module Riaktor
+  module Document
+    class Base < RObject
+      include Attributes
+      include Indexes
+      include Associations
+      include ActiveModel::Validations
+      extend  ActiveModel::Callbacks
+      
+      attr_accessor :links
+      
+      define_model_callbacks :save, :destroy
+      
+      validates_presence_of :key
+      
+      def self.bucket
+        self.to_s.underscore
+      end
+      
+      def self.find(key,opts={})
+        super(key,opts.merge(:bucket => self.bucket))
+      end
+      
+      def self.find_many(keys,opts={})
+        super(keys,opts.merge(:bucket => self.bucket))
+      end
+      
+      def self.save_many(docs)
+        results = {}
+        docs.uniq.compact.in_groups_of(Riaktor::Client.max_concurrency) do |doc_group|
+          threads = []
+          doc_group.compact.each do |doc|
+            threads << Thread.new do
+              begin
+                results[doc] = doc.save
+              rescue Exception => e
+                results[doc] = e
+              end
+            end # Thread.new
+          end # doc_group.each
+          threads.each { |th| th.join }
+        end; results
+      end
+      
+      def self.destroy_many(docs)
+        results = {}
+        docs.uniq.compact.in_groups_of(Riaktor::Client.max_concurrency) do |doc_group|
+          threads = []
+          doc_group.compact.each do |doc|
+            threads << Thread.new do
+              begin
+                results[doc] = doc.destroy
+              rescue Exception => e
+                results[doc] = e
+              end
+            end # Thread.new
+          end # doc_group.each
+          threads.each { |th| th.join }
+        end; results
+      end
+      
+      def bucket
+        self.class.bucket
+      end
+      
+      def in_conflict?
+        super || any_attributes_in_conflict?
+      end
+      
+      def changed?
+        super || any_associations_changed?
+      end
+      
+      alias :ancestor_save :save
+      
+      def save(opts={})
+        return false unless valid?
+        
+        if new_record?
+          if existing = self.class.find(self.key)
+            errors[:key] << "is not unique"
+            return false
+          end
+        end
+        
+        _run_save_callbacks do
+          if self.links and !self.links.empty?
+            opts[:links] = self.links
+          end
+          
+          if ancestor_save(opts)
+            save_attributes
+            save_indexes
+          end
+        end; true
+      end
+      
+      alias :ancestor_destroy :destroy
+      
+      def destroy(opts={})
+        return false if new_record?
+        _run_destroy_callbacks do
+          if ancestor_destroy(opts)
+            destroy_attributes
+            destroy_indexes
+          end
+        end; true
+      end
+      
+      def read_attribute_for_validation(name)
+        case name.to_sym
+        when :key, :value
+          self.send(name.to_sym)
+        else
+          self.send(name.to_sym).value
+        end
+      end
+    end # Base
+  end # Document
+end # Riaktor

data/lib/riaktor/document/index.rb

@@ -0,0 +1,13 @@
+module Riaktor
+  module Document
+    class Index < RObject
+      attr_accessor :parent
+      
+      def save(opts={})
+        if self.parent && self.parent.valid?
+          super(opts)
+        end
+      end
+    end # Attribute
+  end # Document
+end # Riaktor

data/lib/riaktor/document/indexes.rb

@@ -0,0 +1,104 @@
+require "#{File.dirname(__FILE__)}/index"
+
+module Riaktor
+  module Document
+    module Indexes
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def defined_indexes
+          @defined_indexes || {}
+        end
+        
+        def index(attrib_name, opts={})
+          @defined_indexes ||= {}
+          @defined_indexes[attrib_name] = opts
+        end
+        
+        def key_for_index(name,value,opts={})
+          ["indexes",name,Digest::SHA1.hexdigest(self.encode_value(value))].join("--")
+        end
+        
+        def indexes_bucket
+          [self.bucket, "indexes"].join("--")
+        end
+        
+        def find_with_index(name, value, opts={})
+          key = key_for_index(name,value)
+          if index = Riaktor::Document::Index.find(key, {:bucket => indexes_bucket}.merge(opts))
+            self.find(index.value)
+          end
+        end
+      end # ClassMethods
+      
+      module InstanceMethods        
+        def indexes_key_to_name_map
+          @indexes_key_to_name_map ||= begin
+            map = {}
+            self.class.defined_indexes.each do |name, opts|
+              map[key_for_index(name,opts)] = name
+            end; map
+          end
+        end
+        
+        def save_indexes
+          load_attributes
+          Array(self.class.defined_indexes).in_groups_of(Riaktor::Client.max_concurrency).each do |defined_indexes_group|
+            threads = []
+            defined_indexes_group.each do |name_and_opts|
+              next unless name_and_opts
+              name = name_and_opts[0]
+              opts = name_and_opts[1]
+              attrib = @attributes[name]
+              next unless attrib.changed?
+              threads << Thread.new do
+                if !attrib.new_record? and attrib.orig_value
+                  # delete old index
+                  index_key = self.class.key_for_index(name,attrib.orig_value)
+                  if index = Riaktor::Document::Index.find(index_key, :bucket => self.class.indexes_bucket)
+                    index.parent = self
+                    index.destroy
+                  end
+                end
+                if attrib.value
+                  # save new index
+                  index_key = self.class.key_for_index(name,attrib.value)
+                  index = Riaktor::Document::Index.new(:key => index_key, :bucket => self.class.indexes_bucket, :value => self.key)
+                  index.parent = self
+                  index.save
+                end
+              end # Thread.new do
+            end # defined_indexes_group.each
+            threads.each { |th| th.join }
+          end; true
+        end # save_indexes
+        
+        def destroy_indexes
+          load_attributes
+          Array(self.class.defined_indexes).in_groups_of(Riaktor::Client.max_concurrency).each do |defined_indexes_group|
+            threads = []
+            defined_indexes_group.each do |name_and_opts|
+              next unless name_and_opts
+              name = name_and_opts[0]
+              opts = name_and_opts[1]
+              attrib = @attributes[name]
+              next unless attrib.orig_value
+              threads << Thread.new do
+                index_key = self.class.key_for_index(name,attrib.orig_value)
+                if index = Riaktor::Document::Index.find(index_key, :bucket => self.class.indexes_bucket)
+                  index.parent = self
+                  index.destroy
+                end
+              end # Thread.new do
+            end # defined_indexes_group.each
+            threads.each { |th| th.join }
+          end; true
+        end # destroy_indexes
+        
+      end # InstanceMethods
+    end # Attributes
+  end # Document
+end # Riaktor

data/lib/riaktor/document.rb

@@ -0,0 +1,6 @@
+module Riaktor
+  module Document
+  end # Document
+end # Riaktor
+
+require "#{File.dirname(__FILE__)}/document/base"

data/lib/riaktor/r_object/link.rb

@@ -0,0 +1,44 @@
+module Riaktor
+  class RObject
+    class Link
+      attr_accessor :bucket, :key, :tag
+      
+      def self.from_header(link_header)
+        return [] if link_header.nil?
+        links = []
+        link_header.split(",").each do |link_str|
+          url, tag = link_str.split(";")
+          url = url.gsub("<","").gsub(">","").strip.split("/")
+          bucket = url[-2]
+          key = url[-1]
+          tag = tag.split("=")[1].gsub("\"","").strip
+          next if tag == "up"
+          links << new(bucket,key,tag)
+        end; links
+      end
+      
+      def self.to_header(links)
+        links.reject! { |l| l.tag == "up" }
+        (links.collect { |l| l.to_s }).uniq.join(",")
+      end
+      
+      def initialize(bucket, key, tag)
+        @bucket = bucket
+        @key = key
+        @tag = tag
+      end
+      
+      def ==(obj)
+        obj.is_a?(Link) && obj.bucket == self.bucket && obj.key == self.key && obj.tag == self.tag
+      end
+      
+      def to_s
+        "</riak/#{bucket}/#{key}>; riaktag=\"#{tag}\""
+      end
+      
+      def to_doc(klass)
+        klass.find(key, :bucket => bucket)
+      end
+    end # Link
+  end # RObject
+end # Riaktor

data/lib/riaktor/r_object/persistence.rb

@@ -0,0 +1,155 @@
+require "#{File.dirname(__FILE__)}/link"
+
+module Riaktor
+  class RObject
+    module Persistence
+      class SaveError < RuntimeError; end
+      class DestroyError < RuntimeError; end
+      
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def find(key,opts={})
+          find_many([key],opts)[key]
+        end
+        
+        def find_many(keys,opts={})
+          raise(ArgumentError, "missing :bucket") unless opts[:bucket]
+          raise(ArgumentError, "empty keys") if keys.nil? or keys.empty?
+          
+          operations = []
+          keys.each do |key|
+            op = {}
+            op["bucket"] = opts[:bucket]
+            op["key"]    = key
+            op["params"] = { "r" => opts["r"] || 2 }
+            operations  << op
+          end # keys.each
+          
+          found = {}
+          Riaktor::Client.get_many(operations).each do |key_bucket_pair, resp|
+            bucket = key_bucket_pair[0]
+            key = key_bucket_pair[1]
+            case resp["code"]
+            when 200 then
+              found[key] = new(:key => key, 
+                               :bucket => bucket,
+                               :value => decode_value(resp["body"]),
+                               :vector_clock => resp["headers"]["X-Riak-Vclock"],
+                               :links => Link.from_header(resp["headers"]["Link"]),
+                               :new => false)
+            when 300 then
+              found[key] = new(:key => key, 
+                               :bucket => bucket,
+                               :value => nil,
+                               :vector_clock => resp["headers"]["X-Riak-Vclock"],
+                               :links => Link.from_header(resp["headers"]["Link"]),
+                               :new => false)
+              vtags = resp["body"].split("\n")[1..-1]
+              found[key].load_siblings(vtags,{"r" => opts["r"] || 2})
+            else
+              found[key] = nil
+            end
+          end # Riaktor.get_many
+          
+          found
+        end
+        
+        def decode_value(val)
+          case self.encoder
+          when :json
+            Yajl::Parser.parse(val)
+          when :yaml
+            YAML.load(val)
+          end
+        end
+        
+        def encode_value(val)
+          case self.encoder
+          when :json
+            Yajl::Encoder.encode(val)
+          when :yaml
+            YAML.dump(val)
+          end
+        end
+      end # ClassMethods
+      
+      module InstanceMethods
+        def load_siblings(vtags,params={})
+          params["r"] ||= 2
+          @siblings     = {}
+          
+          vtags.each do |vtag|
+            resp = Riaktor::Client.get({ "bucket" => self.bucket, "key" => self.key, 
+              "params" => { "vtag" => vtag }.merge(params) })
+            if resp["code"] == 200
+              @siblings[vtag] = self.class.decode_value(resp["body"])
+            end
+          end
+          
+          @siblings
+        end
+        
+        def resolved!
+          @siblings = nil; true
+        end
+        
+        def in_conflict?
+          !@siblings.nil?
+        end
+        
+        def save(opts={})
+          raise(SaveError, "cannot save with siblings present") if self.in_conflict?
+          if changed? or opts[:force] == true
+            op = {}
+            op["bucket"]  = self.bucket
+            op["key"]     = self.key
+            op["value"]   = self.class.encode_value(self.value)
+            op["params"]  = { "dw" => opts[:dw] || 0, "w" => opts[:w] || 2, "r" => opts[:r] || 2 }
+            op["headers"] = { "X-Riak-Vclock" => self.vector_clock } if self.vector_clock
+            op["headers"]["Link"] = Link.to_header(opts[:links]) if opts[:links]
+            resp = Riaktor::Client.put(op)
+            if [204,404].include?(resp["code"])
+              resp = Riaktor::Client.get(op)
+            end
+            case resp["code"]
+            when 200 then
+              @links = Link.from_header(resp["headers"]["Link"])
+              @vector_clock = resp["headers"]["X-Riak-Vclock"]
+              @new = false
+            when 300 then
+              @links = Link.from_header(resp["headers"]["Link"])
+              @vector_clock = resp["headers"]["X-Riak-Vclock"]
+              @new = false
+              vtags = resp["body"].split("\n")[1..-1]
+              load_siblings(vtags,{"r" => op["params"]["r"]})
+            else
+              raise(SaveError, resp["code"])
+            end # case
+          end
+          true
+        end
+        
+        def destroy(opts={})
+          raise(DestroyError, "cannot destroy with siblings present") if self.in_conflict?
+          raise(DestroyError, "cannot destroy unsaved document") if self.new_record?
+          op = {}
+          op["bucket"] = self.bucket
+          op["key"]    = self.key
+          op["params"]  = { "dw" => opts[:dw] || 0, "w" => opts[:w] || 2, "r" => opts[:r] || 2 }
+          op["headers"] = { "X-Riak-Vclock" => self.vector_clock } if self.vector_clock
+          resp = Riaktor::Client.delete(op)
+          case resp["code"]
+          when 204 then
+            @deleted = true
+          else
+            raise(DestroyError, resp["code"])
+          end # case
+        end
+      end # InstanceMethods
+    end # Persistence
+  end # Document
+end # Riaktor

data/lib/riaktor/r_object.rb

@@ -0,0 +1,46 @@
+require "#{File.dirname(__FILE__)}/r_object/persistence"
+
+module Riaktor
+  class RObject
+    include Persistence
+
+    attr_accessor :key, :bucket, :value, :orig_value, :links, :siblings, :vector_clock, :deleted
+    
+    def self.encoder
+      @encoder || :yaml
+    end
+
+    def self.encoder=(val)
+      @encoder = val
+    end
+    
+    def initialize(opts={})
+      @key          = opts[:key]
+      @value        = opts[:value]
+      @bucket       = opts[:bucket]
+      @siblings     = opts[:siblings]
+      @links        = opts[:links] || []
+      @new          = opts[:new].nil? ? true : opts[:new]
+      @orig_value   = @new == true ? nil : @value.dup rescue nil
+      @vector_clock = opts[:vector_clock]
+    end
+    
+    alias :id :key
+
+    def ==(obj)
+      self.class.to_s == obj.class.to_s && self.key == obj.key
+    end
+    
+    def changed?
+      @value != @orig_value
+    end
+    
+    def new_record?
+      @new == true
+    end
+    
+    def destroyed?
+      @deleted == true
+    end
+  end # RObject
+end # Riaktor

data/lib/riaktor.rb

@@ -17,7 +17,7 @@ gem "activemodel", '= 3.0.0.beta'
 require "active_model"
   
 module Riaktor
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end
 
 require "#{File.dirname(__FILE__)}/riaktor/client"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ben Myles
@@ -146,11 +146,23 @@ extra_rdoc_files:
 - PostInstall.txt
 files: 
 - History.txt
+- lib/riaktor/client.rb
+- lib/riaktor/document/association.rb
+- lib/riaktor/document/associations.rb
+- lib/riaktor/document/attribute.rb
+- lib/riaktor/document/attributes.rb
+- lib/riaktor/document/base.rb
+- lib/riaktor/document/index.rb
+- lib/riaktor/document/indexes.rb
+- lib/riaktor/document.rb
+- lib/riaktor/r_object/link.rb
+- lib/riaktor/r_object/persistence.rb
+- lib/riaktor/r_object.rb
+- lib/riaktor.rb
 - Manifest.txt
 - PostInstall.txt
-- README.rdoc
 - Rakefile
-- lib/riaktor.rb
+- README.rdoc
 - script/console
 - script/destroy
 - script/generate