kvom 6.8.0.beta.200.566.d1df6eb

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gem "pry"
+gem "yajl-ruby"
+
+# Specify your gem's dependencies in kvom.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/kvom.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../../rake_support/git_based_version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "kvom"
+  s.version     = RakeSupport.git_based_version(__FILE__)
+  s.authors     = ["Kristian Hanekamp, Infopark AG"]
+  s.email       = ["kristian.hanekamp@infopark.de"]
+  s.homepage    = ""
+  s.summary     = %q{Key Value Object Mapper}
+  s.description = %q{Use it to build object models in ruby on top of a key value store.}
+
+  s.rubyforge_project = "kvom"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "helpful_configuration"
+
+  s.add_runtime_dependency "couchrest"
+  s.add_runtime_dependency "activemodel"
+  s.add_runtime_dependency "aws-sdk"
+end

data/lib/kvom.rb

@@ -0,0 +1,3 @@
+require "kvom/adapter/base"
+require "kvom/document"
+require "kvom/base"

data/lib/kvom/adapter/base.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/hash/keys'
+
+module Kvom; module Adapter
+
+class Base
+  attr_reader :connection_spec
+
+  attr_reader :documents_loaded_counter, :request_counter
+
+  def initialize(connection_spec_raw)
+    @connection_spec = connection_spec_raw.symbolize_keys
+    @documents_loaded_counter = @request_counter = 0
+  end
+
+  def new_document(key, attributes)
+    raise "implement me in subclass!"
+  end
+
+  def save(doc)
+    raise "implement me in subclass!"
+  end
+
+  def get(key)
+    raise "implement me in subclass!"
+  end
+
+  def destroy(doc)
+    raise "implement me in subclass!"
+  end
+
+  protected
+
+  def count_request(num_requests = 1)
+    @request_counter += num_requests
+    result = yield
+    @documents_loaded_counter += Array === result ? result.size : 1
+    result
+  end
+
+end
+
+end ; end # module Kvom
+

data/lib/kvom/adapter/couchdb_adapter.rb

@@ -0,0 +1,82 @@
+require 'couchrest'
+require 'kvom/adapter/couchdb_document'
+
+module Kvom; module Adapter
+
+class CouchdbAdapter < Kvom::Adapter::Base
+  def new_document(key, attributes)
+    new_document_from_attributes(attributes.merge("_id" => key))
+  end
+
+  def save(doc)
+    doc.couchrest_document.save
+  end
+
+  def get(key)
+    doc =
+        begin
+          count_request {database.get(key) }
+        rescue RestClient::ResourceNotFound
+          raise Kvom::NotFound.for_key(key)
+        end
+    CouchdbDocument.new(doc)
+  end
+
+  def query(hash_value, range_value)
+    params =
+        case range_value
+        when Range
+          {
+            :startkey => "#{hash_value}|#{range_value.begin}",
+            :endkey => "#{hash_value}|#{range_value.end}",
+          }
+        else
+          {
+            :key => "#{hash_value}|#{range_value}",
+          }
+        end
+
+    params[:include_docs] = true
+    count_request {database.all_docs(params)["rows"]}.map do |entry|
+      new_document_from_attributes(entry["doc"])
+    end
+  end
+
+  def destroy(doc)
+    doc.couchrest_document.destroy
+  end
+
+  module BlobSupport
+
+    def blob_url(id)
+      "#{ database_url }/#{ id }/blob"
+    end
+
+    def blob_attachment(id)
+      document = count_request {database.get(id)}
+      document["_attachments"]["blob"]
+    end
+
+  end
+
+  include BlobSupport
+
+  private
+
+  def database_url
+    connection_spec[:url]
+  end
+
+  def new_document_from_attributes(attributes)
+    couch_doc = CouchRest::Document.new(attributes)
+    couch_doc.database = database
+    CouchdbDocument.new(couch_doc)
+  end
+
+  def database
+    @database ||= CouchRest.database(database_url)
+  end
+
+end
+
+end ; end # module Kvom

data/lib/kvom/adapter/couchdb_document.rb

@@ -0,0 +1,23 @@
+module Kvom; module Adapter
+
+class CouchdbDocument < Document
+  attr_accessor :couchrest_document
+
+  def initialize(couchrest_document)
+    self.couchrest_document = couchrest_document
+  end
+
+  def [](name)
+    couchrest_document[name]
+  end
+
+  def []=(name, value)
+    couchrest_document[name] = value
+  end
+
+  def key
+    couchrest_document.id
+  end
+end
+
+end ; end # module Kvom

data/lib/kvom/adapter/dynamodb_adapter.rb

@@ -0,0 +1,116 @@
+require 'aws-sdk'
+require 'kvom/adapter/dynamodb_document'
+
+module Kvom; module Adapter
+
+class DynamodbAdapter < Kvom::Adapter::Base
+  def new_document(key, attributes = nil)
+    DynamodbDocument.new_document(attributes, key, item_for_key(key))
+  end
+
+  def get(key)
+    item = item_for_key(key)
+    count_request {item.exists?} or raise Kvom::NotFound.for_key(key)
+    DynamodbDocument.document_with_item(key, item)
+  end
+
+  def save(doc)
+    doc.save
+  end
+
+  def destroy(doc)
+    doc.destroy
+  end
+
+  def query(hash_value, range_value)
+    count_request do
+      case range_value
+      when String
+        item = item_for_hash_and_range(hash_value, range_value)
+        attributes = item.attributes.to_h
+        if attributes.empty?
+          []
+        else
+          key = key_from_item(item)
+          [DynamodbDocument.document_from_query(attributes, key, item)]
+        end
+      when Range
+        dynamo_range_start = dynamo_range_value(range_value.begin)
+        dynamo_range_end = dynamo_range_value(range_value.end)
+
+        query_options = {
+          :hash_value => partitioned_hash_value(hash_value),
+          :range_value => Range.new(dynamo_range_start, dynamo_range_end),
+          :select => :all,
+        }
+        table.items.query(query_options).map do |item_data|
+          item = item_data.item
+          key = key_from_item(item)
+          DynamodbDocument.document_from_query(item_data.attributes, key, item)
+        end
+      end
+    end
+  end
+
+  private
+
+  def table
+    @table ||= begin
+      # TODO define dynamo endpoint externally?
+      AWS.config(:dynamo_db_endpoint => 'dynamodb.eu-west-1.amazonaws.com')
+
+      # TODO: explicit nil testing
+      credentials = {
+        :access_key_id => connection_spec[:access_key_id],
+        :secret_access_key => connection_spec[:secret_access_key],
+      }
+      table = AWS::DynamoDB.new(credentials).tables[connection_spec[:table]]
+      table.hash_key = [:hash_key, :string]
+      table.range_key = [:range_key, :string]
+      table
+    end
+  end
+
+  def key_from_item(item)
+    hash_value, range_value = item.hash_value, item.range_value
+    range_value = "" if range_value == " " # range_from_dynamo_range
+    hash_value = hash_value[(partition.length + 1)..-1] if partition # unpartitioned_hash_value
+    [hash_value, range_value].join("|")
+  end
+
+  def item_for_key(key)
+    item_for_hash_and_range(*(key.split("|", 2)))
+  end
+
+  def item_for_hash_and_range(hash, range)
+    table.items[partitioned_hash_value(hash), dynamo_item_range_value(range)]
+  end
+
+  def dynamo_item_range_value(range_value)
+    # conflict with the empty range value
+    range_value == " " and raise "Unexpected range <single space>"
+    dynamo_range_value(range_value)
+  end
+
+  def dynamo_range_value(range_value)
+    case range_value || ""
+    when ""
+      # range_key is required and must not be empty
+      " "
+    else
+      range_value
+    end
+  end
+
+  def partitioned_hash_value(hash_value)
+    return hash_value unless partition
+    "#{partition}|#{hash_value}"
+  end
+
+  def partition
+    @partition ||= connection_spec[:partition]
+  end
+
+end
+
+end ; end # module Kvom

data/lib/kvom/adapter/dynamodb_document.rb

@@ -0,0 +1,159 @@
+module Kvom; module Adapter
+
+class DynamodbDocument < Document
+  class << self
+    def new_document(attributes, key, item)
+      new(key, item, :attributes => attributes)
+    end
+
+    def document_with_item(key, item)
+      new(key, item)
+    end
+
+    def document_from_query(attributes, key, item)
+      new(key, item, :item_attributes => attributes)
+    end
+
+  end
+
+  attr_reader :key
+
+  def initialize(key, item, provided_attributes = nil)
+    @key = key
+    @dynamo_item = item
+    if provided_attributes
+      if provided_attributes.key?(:attributes)
+        @kv = provided_attributes[:attributes] || {}
+        @modified = true
+      elsif provided_attributes.key?(:item_attributes)
+        @kv = attributes_from_item_attributes(provided_attributes[:item_attributes])
+      end
+    end
+  end
+
+  def [](name)
+    kv[name]
+  end
+
+  def []=(name, value)
+    case value
+    when String, Fixnum, nil
+      # okay ...
+    else
+      raise "Unsupported value type: #{value.class.name}"
+    end
+    @modified = true
+    kv[name] = value
+  end
+
+  def save
+    return unless modified?
+    dynamo_attributes = @kv.inject({}) do |memo, (key, value)|
+      case value
+      when nil
+        # skip
+      when String, Fixnum, BigDecimal
+        memo[key] = value
+      else
+        raise "Unsupported value type #{value.class.to_s}"
+      end
+      memo
+    end
+    dynamo_attributes["hash_key"] = @dynamo_item.hash_value
+    dynamo_attributes["range_key"] = @dynamo_item.range_value
+    dynamo_attributes["@rev"] = new_revision = (@rev || 0) + 1
+    # might be improved to saving only changed attributes
+    @dynamo_item.table.items.put(dynamo_attributes, revision_condition)
+    @rev = new_revision
+    @modified = false
+  end
+
+  def destroy
+    @dynamo_item.delete(revision_condition)
+  end
+
+  private
+
+  def modified?
+    @modified
+  end
+
+  def attributes_from_item_attributes(item_attributes)
+    attributes = AttributesFromItemAttributes.from(item_attributes)
+    @rev = attributes["@rev"]
+    attributes
+  end
+
+  def kv
+    @kv ||= attributes_from_item_attributes(@dynamo_item.attributes.to_h)
+  end
+
+  def revision
+    @rev
+  end
+
+  def revision_condition
+    dynamo_condition("@rev" => @rev)
+  end
+
+  def dynamo_condition(condition)
+    present_condition = {}
+    missing_condition = []
+    condition.each do |(key, value)|
+      if value
+        present_condition[key] = value
+      else
+        missing_condition << key
+      end
+    end
+    options = {}
+    options[:if] = present_condition unless present_condition.empty?
+    options[:unless] = missing_condition unless missing_condition.empty?
+    options
+  end
+
+  class AttributesFromItemAttributes
+    def self.from(attributes)
+      attributes.delete("hash_key")
+      attributes.delete("range_key")
+      meta = attributes.delete("@meta.json")
+      return attributes unless meta
+      meta = MultiJson.decode(meta)
+      coding = meta["coding"]
+      return attributes if !coding || coding.empty?
+      new(attributes, coding)
+    end
+
+    def initialize(attributes, coding)
+      @attributes = attributes
+      @coding = coding
+    end
+
+    def [](name)
+      value = @attributes[name]
+      coding = @coding[name]
+      return value unless coding
+      coding == "json" or raise "Unexpected coding #{coding} for attribute #{name}"
+      value = parse_json_value(value)
+      self[name] = value
+    end
+
+    def []=(name, value)
+      @coding.delete(name)
+      @attributes[name] = value
+    end
+
+    private
+
+    def parse_json_value(value)
+      case value[0]
+      when ?{
+        MultiJson.decode(value)
+      else
+        MultiJson.decode("{\"key\":#{value}}")["key"]
+      end
+    end
+  end
+end
+
+end ; end # module Kvom

data/lib/kvom/base.rb

@@ -0,0 +1,116 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+require 'active_model/naming'
+require 'securerandom'
+
+require 'kvom/model_identity'
+
+module Kvom
+
+class NotFound < ::StandardError
+  def self.for_key(key)
+    new(%(document with key "#{key}" not found))
+  end
+end
+
+class Base
+  include ModelIdentity
+  extend ActiveModel::Naming
+
+  class_attribute :key_prefix
+
+  class << self
+    def create(attributes = {})
+      new(attributes).tap { |model| model.save }
+    end
+
+    def find(id)
+      raise "no id given" if id.blank?
+      new(find_document(id))
+    end
+
+    def find_by_id(id)
+      find(id)
+    rescue NotFound
+      nil
+    end
+
+    def property(name_raw)
+      name = name_raw.to_s
+
+      define_method name do
+        read_attribute(name)
+      end
+      define_method "#{name}=" do |value|
+        write_attribute(name, value)
+      end
+    end
+
+    # default implementation for the class_attribute
+    def key_prefix
+      to_s
+    end
+
+    def adapter
+      raise "must be overwritten in subclasses"
+    end
+
+    def key_for(id)
+      "#{key_prefix}/id/#{id}|"
+    end
+
+    private
+
+    def find_document(id)
+      adapter.get(key_for(id))
+    end
+
+  end
+
+  def initialize(doc_or_attrs = {})
+    if doc_or_attrs.is_a?(Document)
+      @document = doc_or_attrs
+    else
+      attrs = doc_or_attrs.stringify_keys
+
+      attrs["id"] ||= SecureRandom.hex(8)
+
+      id = attrs["id"]
+      @document = self.class.adapter.new_document(self.class.key_for(id), attrs)
+      @new = true
+    end
+  end
+
+  def document
+    @document
+  end
+
+  def save
+    self.class.adapter.save(@document)
+    @new = false
+  end
+
+  def id
+    @document["id"]
+  end
+
+  def read_attribute(name)
+    @document[name]
+  end
+
+  def write_attribute(name, value)
+    @document[name] = value
+  end
+
+  def new?
+    @new
+  end
+
+  def destroy
+    self.class.adapter.destroy(@document)
+  end
+end
+
+end # module Kvom
+

data/lib/kvom/document.rb

@@ -0,0 +1,17 @@
+module Kvom
+
+class Document
+  def key
+    raise "implement me in subclass!"
+  end
+
+  def [](name)
+    raise "implement me in subclass!"
+  end
+
+  def []=(name, value)
+    raise "implement me in subclass!"
+  end
+end
+
+end # module Kvom

data/lib/kvom/model_identity.rb

@@ -0,0 +1,23 @@
+module Kvom
+
+module ModelIdentity # :nodoc:
+  # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
+  # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+  def ==(comparison_object)
+    comparison_object.equal?(self) ||
+      (comparison_object.instance_of?(self.class) && comparison_object.id == id)
+  end
+
+  # Delegates to ==
+  def eql?(comparison_object)
+    self == (comparison_object)
+  end
+
+  # Delegates to id in order to allow two records of the same type and id to work with something like:
+  #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+  def hash
+    id.hash
+  end
+end
+
+end # module Kvom

data/spec/base_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+class CustomKeyPrefixModel < TestModel
+  self.key_prefix = "spam_prefix"
+end
+
+class ModelWithoutAdapter < Kvom::Base
+end
+
+def random_id
+  rand.to_s
+end
+
+describe Kvom::Base do
+  it "should complain when no adapter is specified" do
+    expect { ModelWithoutAdapter.find("spam") }.to raise_error(/overwritten/)
+  end
+
+  it "should provide access to the underlying document" do
+    example = ExampleModel.create(:spam => "foo")
+    example.document["spam"].should == "foo"
+    example.document.should be_a(Kvom::Document)
+  end
+
+  describe "getters and setters" do
+    it "work for freshly created models" do
+      example = ExampleModel.create(:spam => "foo")
+      example.spam.should == "foo"
+      example.spam = "bar"
+      example.spam.should == "bar"
+    end
+
+    it "handle access via string as well as symbols" do
+      example = ExampleModel.create(:spam => "foo")
+      example.spam.should == "foo"
+      example = ExampleModel.create("spam" => "foo")
+      example.spam.should == "foo"
+    end
+
+    it "works for models loaded from database" do
+      example = ExampleModel.create(:spam => "foo")
+      example.save
+
+      loaded = ExampleModel.find(example.id)
+      loaded.spam.should == "foo"
+    end
+  end
+
+  it "should accept an id as string or symbol" do
+    ExampleModel.create(:id => (first_id = random_id))
+    ExampleModel.create("id" => (second_id = random_id))
+    ExampleModel.find(first_id)
+    ExampleModel.find(second_id)
+  end
+
+  describe "model id's" do
+    it "should use a custom prefix when given" do
+      CustomKeyPrefixModel.new.document.key.should =~ /^spam_prefix\/id\/.+/
+    end
+
+    it "should use a default prefix" do
+      ExampleModel.new.document.key.should =~ /^ExampleModel\/id\/.+/
+    end
+  end
+
+  describe "BaseModel#find" do
+    it "should refuse to find with an empty id" do
+      expect { ExampleModel.find("") }.to raise_error /no id given/
+    end
+
+    it "should find model instances" do
+      example = ExampleModel.create(:spam => "foo")
+      ExampleModel.find(example.id).id.should == example.id
+      ExampleModel.find(example.id).spam.should == "foo"
+    end
+
+    it "should raise exception when instances cannot be found" do
+      model_id = random_id
+      expect {
+        ExampleModel.find(model_id)
+      }.to raise_error(Kvom::NotFound, %r(document.*"ExampleModel/id/#{model_id}|"/))
+    end
+  end
+
+  describe "BaseModel#find_by_id" do
+    context "when called with an empty id" do
+      it "raises an error complaining about the missing id" do
+        expect { ExampleModel.find_by_id("") }.to raise_error /no id given/
+      end
+    end
+
+    context "when called with an id of an existing model" do
+      let(:existing_model) {
+        ExampleModel.create
+      }
+
+      it "returns the model instance" do
+        id = existing_model.id
+        result = ExampleModel.find_by_id(id)
+        result.should be_instance_of(ExampleModel)
+        result.id.should == id
+      end
+    end
+
+    context "when called with an id where no model exists for" do
+      it "should return nil" do
+        ExampleModel.find_by_id(random_id).should be_nil
+      end
+    end
+  end
+
+  describe "destroying models" do
+
+    context "when the model has been created without id" do
+
+      let(:model_without_specified_id) {ExampleModel.create}
+
+      it "destroys the model" do
+        id = model_without_specified_id.id
+        expect {
+          model_without_specified_id.destroy
+        }.to change {
+          ExampleModel.find_by_id(id)
+        }.to nil
+      end
+
+    end
+
+    context "when the model has been created with an id" do
+
+      let(:model_with_id) {ExampleModel.create(:id => rand.to_s)}
+
+      it "destroys the model" do
+        id = model_with_id.id
+        expect {
+          model_with_id.destroy
+        }.to change {
+          ExampleModel.find_by_id(id)
+        }.to nil
+      end
+
+    end
+
+    context "when the model instance has been loaded from database" do
+
+      let(:model_from_db) {ExampleModel.find_by_id(ExampleModel.create.id)}
+
+      it "destroys the model" do
+        id = model_from_db.id
+        expect {
+          model_from_db.destroy
+        }.to change {
+          ExampleModel.find_by_id(id)
+        }.to nil
+      end
+
+    end
+
+  end
+
+  describe "#new?" do
+
+    context "when instantiated from attributes" do
+
+      let(:model_from_attributes) {ExampleModel.new({})}
+
+      it "is new" do
+        model_from_attributes.should be_new
+      end
+
+      context "and saved" do
+
+        before do
+          model_from_attributes.save
+        end
+
+        it "is not new" do
+          model_from_attributes.should_not be_new
+        end
+
+      end
+
+      context "including id" do
+
+        let(:model_id) {"static" + rand.to_s}
+        let(:model_from_attributes_including_id) {ExampleModel.new({"id" => model_id})}
+
+        before do
+          model_from_attributes_including_id.id.should == model_id
+        end
+
+        it "is new" do
+          model_from_attributes.should be_new
+        end
+
+      end
+    end
+
+    context "when instantiated from database" do
+
+      let(:model_from_database) {ExampleModel.find_by_id(ExampleModel.create.id)}
+
+      it "returns falsy" do
+        model_from_database.should_not be_new
+      end
+    end
+  end
+
+
+  it "should use ModelIdentity" do
+    ExampleModel.should include(Kvom::ModelIdentity)
+  end
+
+  it "should be extended to use ActiveModel::Naming " do
+    ExampleModel.model_name.should == "ExampleModel"
+  end
+end

data/spec/counter_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Kvom::Base do
+  let(:model) { ExampleModel.create }
+
+  it "should count the number of requests" do
+    expect {
+      ExampleModel.find(model.id)
+    }.to change(ExampleModel.adapter, :request_counter).by(1)
+  end
+
+  it "should count the number of document loaded" do
+    expect {
+      ExampleModel.find(model.id)
+    }.to change(ExampleModel.adapter, :documents_loaded_counter).by(1)
+  end
+end

data/spec/model_identity_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+require "kvom/model_identity"
+
+describe Kvom::ModelIdentity do
+  class IdTest
+    include Kvom::ModelIdentity
+    attr_accessor :id
+
+    def initialize(id)
+      self.id = id
+    end
+  end
+
+  it "should be identical iff it's id is identical" do
+    IdTest.new("foo").should == IdTest.new("foo")
+    IdTest.new("foo").should_not == IdTest.new("bar")
+  end
+
+  it "should be eql iff it's id is identical" do
+    IdTest.new("foo").should be_eql IdTest.new("foo")
+    IdTest.new("foo").should_not be_eql IdTest.new("bar")
+  end
+
+  it "should be usable as hash keys" do
+    hash = {IdTest.new("foo") => "FOO", IdTest.new("bar") => "BAR"}
+    hash[IdTest.new("foo")].should == "FOO"
+    hash[IdTest.new("bar")].should == "BAR"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift(Pathname(__FILE__) + "../lib")
+
+require 'pry'
+
+require 'kvom'
+
+class TestModel < Kvom::Base
+  def self.adapter
+    @adapter ||=
+      case (type = ENV['KVOM_ADAPTER_TYPE'] || "couch")
+      when "couch"
+        require "kvom/adapter/couchdb_adapter"
+        require 'multi_json'
+        MultiJson.engine = :yajl
+        database_name = "kvom-unit_tests"
+        CouchRest.database!(database_name)
+        Kvom::Adapter::CouchdbAdapter.new({
+          :url => database_name,
+        })
+      when /dynamo/
+        require "kvom/adapter/dynamodb_adapter"
+        require File.expand_path("../../../tasks/support/local_config", __FILE__)
+        options = {
+          :table => "test-kvom",
+          :access_key_id => local_config["aws_access_key_id"],
+          :secret_access_key => local_config["aws_secret_access_key"],
+        }
+        options[:partition] = "korb" if type == "partitioned_dynamo"
+        Kvom::Adapter::DynamodbAdapter.new(options)
+      end
+  end
+end
+
+class ExampleModel < TestModel
+  property :spam
+end
+

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification 
+name: kvom
+version: !ruby/object:Gem::Version 
+  hash: -215055160403
+  prerelease: 6
+  segments: 
+  - 6
+  - 8
+  - 0
+  - beta
+  - 200
+  - 566
+  - d
+  - 1
+  - df
+  - 6
+  - eb
+  version: 6.8.0.beta.200.566.d1df6eb
+platform: ruby
+authors: 
+- Kristian Hanekamp, Infopark AG
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: helpful_configuration
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: couchrest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: aws-sdk
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+description: Use it to build object models in ruby on top of a key value store.
+email: 
+- kristian.hanekamp@infopark.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- kvom.gemspec
+- lib/kvom.rb
+- lib/kvom/adapter/base.rb
+- lib/kvom/adapter/couchdb_adapter.rb
+- lib/kvom/adapter/couchdb_document.rb
+- lib/kvom/adapter/dynamodb_adapter.rb
+- lib/kvom/adapter/dynamodb_document.rb
+- lib/kvom/base.rb
+- lib/kvom/document.rb
+- lib/kvom/model_identity.rb
+- spec/base_spec.rb
+- spec/counter_spec.rb
+- spec/model_identity_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: kvom
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Key Value Object Mapper
+test_files: 
+- spec/base_spec.rb
+- spec/counter_spec.rb
+- spec/model_identity_spec.rb
+- spec/spec_helper.rb