orm_adapter-couchbase 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d55904c8d5e90c57b61d5561d1c1ffe63e0e8eb5
+  data.tar.gz: f49d20652726d695708a784ee3372c9e147d0ce5
+SHA512:
+  metadata.gz: 63119511c0b60c945bff3f403d26cf96fc2c0ed52e1471b8d0f4f66305cba60b9cddaea694e24449edffa343d2c46b12672c7682583b45c4448dc8e7b4643ec8
+  data.tar.gz: 8e430a5629d43526a6201d60a97aa6de349a222cdfb6bcc37dd563f6cbcc4c055d16d2aa4730a8df7e3ce3896445f3ab351ab72ced591bbf48e47004f1f37132

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in orm_adapter-couchbase.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Philipp Fehre
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# OrmAdapterCouchbase
+
+WARNING: This is not finished, and very early stage to see if this can work
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'orm_adapter-couchbase'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install orm_adapter-couchbase
+
+## Usage
+
+See the [specs for
+details](https://github.com/sideshowcoder/orm_adapter-couchbase/blob/master/spec/couchbase_spec.rb).
+The Couchbase ORM adapter relies on at least the `all` view to be present which
+should simple return all the object for a given type. This doesn't have great
+performance of course, like any full scan, so it's recommended to create
+additional views to query by other attributes. If you want to for example query
+a user by name, create a view for it.
+
+```ruby
+class User < Couchbase::Model
+  attribute :name
+  view :by_name
+end
+```
+
+Currently only single attributes are supported, but the idea is to support
+others via `by_name_and_rating` in the future.
+
+## ORM Adapter
+
+> "Provides a single point of entry for popular ruby ORMs. Its target audience
+> is gem authors who want to support more than one ORM."
+
+For more information see the [orm_adapter
+project](http://github.com/ianwhite/orm_adapter).
+
+## Development / Testing
+
+This project is tested against `orm_adapter` to make sure it works as
+advertised.
+
+To run the tests:
+
+```
+$ rake spec
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/orm_adapter-couchbase.rb

@@ -0,0 +1,4 @@
+require "orm_adapter"
+require "orm_adapter-couchbase/version"
+require "orm_adapter-couchbase/couchbase" if defined?(Couchbase::Model)
+

data/lib/orm_adapter-couchbase/couchbase.rb

@@ -0,0 +1,168 @@
+require "couchbase/model"
+require "orm_adapter-couchbase/ext/couchbase_model_equality"
+require "orm_adapter-couchbase/ext/couchbase_model_patches"
+require "orm_adapter-couchbase/ext/couchbase_model_has_many"
+
+module Couchbase
+  class Model
+    extend OrmAdapter::ToAdapter
+
+    class OrmAdapter < OrmAdapter::Base
+
+      class MissingViewException < StandardError
+        def initialize view_name
+          message = "view named #{view_name} is not defined"
+          super message
+        end
+      end
+
+      def create! attrs
+        # make sure our views produce consistent data
+        klass.create! attrs
+      end
+
+      def destroy model
+        return nil unless model.is_a? klass
+
+        # Hack to get around delete removing the id from the model
+        id = model.id
+        model.delete
+        model.id = id
+      end
+
+      def get! id
+        klass.find wrap_key(id)
+      end
+
+      def get id
+        klass.find_by_id wrap_key(id)
+      end
+
+      def find_all options = {}
+
+        view_name, view_options, options = view_for_options(options)
+
+        conditions, order, limit, offset = extract_conditions!(options)
+
+        stream = klass.send(view_name, view_options)
+
+        # deal with everything which wasn't handled via the view
+        stream = apply_conditions(stream, conditions)
+        stream = apply_order(stream, order)
+        stream = stream.drop(offset) if offset
+        stream = stream.take(limit) if limit
+
+        stream.to_a # make sure to return an array
+      end
+
+      def find_first options = {}
+        id = options.delete(:id)
+        conditions, _ = extract_conditions!(options.dup)
+
+        if id
+          apply_conditions([get(id)], conditions).first
+        else
+          find_all(options).first
+        end
+      end
+
+      private
+      def apply_conditions stream, conditions
+        return stream if conditions.empty?
+        stream.select { |item| satisfies_conditions? item, conditions }
+      end
+
+      def satisfies_conditions? item, conditions
+        conditions.all? { |field, value| item.send(field) == value }
+      end
+
+      def apply_order stream, order
+        return stream if order.empty?
+
+        stream.to_a.sort_by do |item|
+          sort = []
+          order = order.to_enum
+          o = order.next
+          loop do
+            case o
+            when Array
+              value = item.send(o[0])
+              value = invert_value(value) if o[1] == :desc
+              sort.push(value)
+            else
+              value = item.send(o[0])
+              case order.peek
+              when :asc
+                begin
+                  order.next
+                rescue StopIteration
+                  break
+                end
+              when :desc
+                value = invert_value(value)
+                begin
+                  order.next
+                rescue StopIteration
+                  break
+                end
+              end
+              sort.push(value)
+            end
+            begin
+              o = order.next
+            rescue StopIteration
+              break
+            end
+          end
+          sort
+        end
+      end
+
+      def invert_value value
+        case value
+        when String
+          inverse = []
+          value.each_codepoint { |c| inverse.push(-c) }
+          inverse
+        else
+          -value
+        end
+      end
+
+      def view_for_options options
+        view_name = :all
+        view_options = { :stale => false }
+        conditions, order, limit, offset = extract_conditions!(options.dup)
+
+        # TODO would be nice to merge multiple conditions into one view name
+        # for example users have a rating, and the comprised key is [user,
+        # rating] if the view is named "by_user_and_rating" we could then merge
+        # this into one and even apply the ordering in one go
+        remaining_conditions = conditions.reject { |condition, value|
+          if klass.respond_to?("by_#{condition}")
+            view_name = "by_#{condition}".to_sym
+            view_options[:key] = value
+          end
+        }
+
+        options = { :conditions => remaining_conditions, :order => order }
+
+        if remaining_conditions.empty?
+          # merge limit, and offset conditions into view query
+          view_options[:limit] = limit if limit
+          view_options[:skip] = offset if offset
+        else
+          options[:limit] = limit if limit
+          options[:offset] = offset if offset
+        end
+
+        raise MissingViewException.new(view_name) unless klass.respond_to?(view_name)
+
+        [view_name, view_options, options]
+      end
+
+    end
+  end
+end
+
+

data/lib/orm_adapter-couchbase/ext/couchbase_model_equality.rb

@@ -0,0 +1,14 @@
+module Couchbase
+  class Model
+
+    # define the equality as id equality this should be the default
+    # but it isn't ...
+    #
+    # TODO file a bug about this!
+    #
+    def == other
+      id == other.id
+    end
+
+  end
+end

data/lib/orm_adapter-couchbase/ext/couchbase_model_has_many.rb

@@ -0,0 +1,24 @@
+require 'active_support/inflector'
+
+module Couchbase
+  class Model
+
+    # define a has_many relationship, this is comprise of a view and and array
+    # with referential keys
+    def self.has_many(name, options = {})
+      assoc_name = name.to_s.singularize
+      ref = "#{assoc_name}_ids"
+      attribute(ref, :default => [])
+      assoc = (options[:wrapper_class] || assoc_name).to_s.camelize.constantize
+
+      define_method("#{name}=") do |others|
+        raise TypeError unless others.all? { |o| o.is_a? assoc }
+        self.send("#{ref}=", others.map(&:id))
+      end
+      define_method(name) do
+        assoc.find(self.send(ref))
+      end
+    end
+
+  end
+end

data/lib/orm_adapter-couchbase/ext/couchbase_model_patches.rb

@@ -0,0 +1,40 @@
+module Couchbase
+  class Model
+
+    attr_accessor :type
+
+    # Current master (072262e) version of belongs to
+    #
+    # support passing a class which is not supported in the current 0.5.3 but
+    # already in master
+    #
+    # - added suppport for assigning to belongs_to
+    #
+    def self.belongs_to(name, options = {})
+      ref = "#{name}_id"
+      attribute(ref)
+      assoc = (options[:class_name] || name).to_s.camelize.constantize
+      define_method(name) do
+        assoc.find(self.send(ref))
+      end
+      define_method("#{name}=") do |other|
+        raise TypeError unless other.is_a? assoc
+        self.send("#{ref}=", other.id)
+      end
+    end
+
+    #
+    # updating attributes should fail for invalid attributes, not simply ignore
+    # them
+    #
+    def update_attributes(attrs)
+      if id = attrs.delete(:id)
+        @id = id
+      end
+      attrs.each do |key, value|
+        setter = :"#{key}="
+        send(setter, value)
+      end
+    end
+  end
+end

data/lib/orm_adapter-couchbase/version.rb

@@ -0,0 +1,3 @@
+module OrmAdapterCouchbase
+  VERSION = "0.1.0"
+end

data/orm_adapter-couchbase.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'orm_adapter-couchbase/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "orm_adapter-couchbase"
+  spec.version       = OrmAdapterCouchbase::VERSION
+  spec.authors       = ["Philipp Fehre"]
+  spec.email         = ["philipp.fehre@googlemail.com"]
+  spec.description   = %q{Adds Couchbase support to ORM Adapter}
+  spec.summary       = %q{Use Couchbase Model to add support for Couchbase ORM Adapter}
+  spec.homepage      = "https://github.com/sideshowcoder/orm_adapter-couchbase"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "couchbase-model", "~> 0.5.3"
+  spec.add_dependency "orm_adapter", "~> 0.5.0"
+
+  spec.add_development_dependency "rspec", ">= 2.4.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/couchbase_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "example_app_shared"
+
+
+if !defined?(Couchbase::Model) || !(Couchbase.connect(:bucket => "orm_adapter") rescue nil)
+  puts "** require 'couchbase-model' and start couchbase with a bucket 'orm_adapter' created to run the specs in #{__FILE__}"
+else
+
+  # this is needed to get around the circular dependency since we need to
+  # constantize Note as well as User to have has_many and belongs_to of damn
+  # circular dependency
+  class Note < Couchbase::Model
+  end
+
+  class User < Couchbase::Model
+    attribute :name
+    attribute :rating
+    has_many :notes
+    view :all, :by_name
+  end
+
+  class Note < Couchbase::Model
+    attribute :body, :default => "made by orm"
+    belongs_to :owner, :class_name => "User"
+    view :all
+  end
+
+  module OrmAdapterCouchbaseSpec
+
+    Couchbase.connection_options = { :bucket => "orm_adapter" }
+    Couchbase::Model::Configuration.design_documents_paths = [File.dirname(__FILE__) + "/design_documents/"]
+
+
+    # here be the specs!
+    describe Couchbase::Model::OrmAdapter do
+      before do
+        Couchbase.bucket.flush
+        User.ensure_design_document!
+        Note.ensure_design_document!
+      end
+
+      it_should_behave_like "example app with orm_adapter" do
+        let(:user_class) { User }
+        let(:note_class) { Note }
+      end
+    end
+  end
+end

data/spec/design_documents/note/all/map.js

@@ -0,0 +1,6 @@
+/*jshint -W025:false */
+function (doc, meta) {
+  if (doc.type === "note") {
+    emit(meta.id, null);
+  }
+}

data/spec/design_documents/user/all/map.js

@@ -0,0 +1,6 @@
+/*jshint -W025:false */
+function (doc, meta) {
+  if (doc.type === "user") {
+    emit(meta.id, null);
+  }
+}

data/spec/design_documents/user/by_name/map.js

@@ -0,0 +1,6 @@
+/*jshint -W025:false */
+function (doc, meta) {
+  if (doc.type === "user") {
+    emit(doc.name, null);
+  }
+}

data/spec/design_documents/user/notes/map.js

@@ -0,0 +1,6 @@
+/*jshint -W025:false */
+function (doc, meta) {
+  if (doc.type === "note") {
+    emit(doc.user_id, null);
+  }
+}

data/spec/example_app_shared.rb

@@ -0,0 +1,242 @@
+# Copied from orm_adapter and fixed some Specs
+
+# to test your new orm_adapter, make an example app that matches the functionality
+# found in the existing specs for example, look at spec/orm_adapter/adapters/active_record_spec.rb
+#
+# Then you can execute this shared spec as follows:
+#
+#   it_should_behave_like "execute app with orm_adapter" do
+#     let(:user_class) { User }
+#     let(:note_class) { Note }
+#
+#     # optionaly define the following functions if the ORM does not support
+#     # this syntax - this should NOT use the orm_adapter, because we're testing that
+#     def create_model(klass, attrs = {})
+#       klass.create!(attrs)
+#     end
+#
+#     def reload_model(model)
+#       model.class.find(model.id)
+#     end
+#   end
+#
+shared_examples_for "example app with orm_adapter" do
+
+  def create_model(klass, attrs = {})
+    klass.create!(attrs)
+  end
+
+  def reload_model(model)
+    model.class.find(model.id)
+  end
+
+  describe "an ORM class" do
+    subject { note_class }
+
+    it "#to_adapter should return an adapter instance" do
+      subject.to_adapter.should be_a(OrmAdapter::Base)
+    end
+
+    it "#to_adapter should return an adapter for the receiver" do
+      subject.to_adapter.klass.should == subject
+    end
+
+    it "#to_adapter should be cached" do
+      subject.to_adapter.object_id.should == subject.to_adapter.object_id
+    end
+  end
+
+  describe "adapter instance" do
+    let(:note_adapter) { note_class.to_adapter }
+    let(:user_adapter) { user_class.to_adapter }
+
+    describe "#get!(id)" do
+      it "should return the instance with id if it exists" do
+        user = create_model(user_class)
+        user_adapter.get!(user.id).should == user
+      end
+
+      it "should allow to_key like arguments" do
+        user = create_model(user_class)
+        user_adapter.get!(user.to_key).should == user
+      end
+
+      it "should raise an error if there is no instance with that id" do
+        lambda { user_adapter.get!("nonexistent id") }.should raise_error
+      end
+    end
+
+    describe "#get(id)" do
+      it "should return the instance with id if it exists" do
+        user = create_model(user_class)
+        user_adapter.get(user.id).should == user
+      end
+
+      it "should allow to_key like arguments" do
+        user = create_model(user_class)
+        user_adapter.get(user.to_key).should == user
+      end
+
+      it "should return nil if there is no instance with that id" do
+        user_adapter.get("nonexistent id").should be_nil
+      end
+    end
+
+    describe "#find_first" do
+      describe "(conditions)" do
+        it "should return first model matching conditions, if it exists" do
+          user = create_model(user_class, :name => "Fred")
+          user_adapter.find_first(:name => "Fred").should == user
+        end
+
+        it "should return nil if no conditions match" do
+          user_adapter.find_first(:name => "Betty").should == nil
+        end
+
+        it 'should return the first model if no conditions passed' do
+          user = create_model(user_class)
+          create_model(user_class)
+          user_adapter.find_first.should == user
+        end
+
+        it "when conditions contain associated object, should return first model if it exists" do
+          user = create_model(user_class)
+          note = create_model(note_class, :owner => user)
+          note_adapter.find_first(:owner => user).should == note
+        end
+
+        it "understands :id as a primary key condition (allowing scoped finding)" do
+          create_model(user_class, :name => "Fred")
+          user = create_model(user_class, :name => "Fred")
+          user_adapter.find_first(:id => user.id, :name => "Fred").should == user
+          user_adapter.find_first(:id => user.id, :name => "Not Fred").should be_nil
+        end
+      end
+
+      describe "(:order => <order array>)" do
+        it "should return first model in specified order" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user_adapter.find_first(:order => [:name, [:rating, :desc]]).should == user2
+        end
+      end
+
+      describe "(:conditions => <conditions hash>, :order => <order array>)" do
+        it "should return first model matching conditions, in specified order" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user_adapter.find_first(:conditions => {:name => "Fred"}, :order => [:rating, :desc]).should == user2
+        end
+      end
+    end
+
+    describe "#find_all" do
+      describe "(conditions)" do
+        it "should return only models matching conditions" do
+          user1 = create_model(user_class, :name => "Fred")
+          user2 = create_model(user_class, :name => "Fred")
+          user3 = create_model(user_class, :name => "Betty")
+          user_adapter.find_all(:name => "Fred").to_a.should =~ [user1, user2]
+        end
+
+        it "should return all models if no conditions passed" do
+          user1 = create_model(user_class, :name => "Fred")
+          user2 = create_model(user_class, :name => "Fred")
+          user3 = create_model(user_class, :name => "Betty")
+          user_adapter.find_all.to_a.should =~ [user1, user2, user3]
+        end
+
+        it "should return empty array if no conditions match" do
+          user_adapter.find_all(:name => "Fred").should == []
+        end
+
+        it "when conditions contain associated object, should return first model if it exists" do
+          user1, user2 = create_model(user_class), create_model(user_class)
+          note1 = create_model(note_class, :owner => user1)
+          note2 = create_model(note_class, :owner => user2)
+          note_adapter.find_all(:owner => user2).should == [note2]
+        end
+      end
+
+      describe "(:order => <order array>)" do
+        it "should return all models in specified order" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user3 = create_model(user_class, :name => "Betty", :rating => 1)
+          user_adapter.find_all(:order => [:name, [:rating, :desc]]).should == [user3, user2, user1]
+        end
+      end
+
+      describe "(:conditions => <conditions hash>, :order => <order array>)" do
+        it "should return only models matching conditions, in specified order" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user3 = create_model(user_class, :name => "Betty", :rating => 1)
+          user_adapter.find_all(:conditions => {:name => "Fred"}, :order => [:rating, :desc]).should == [user2, user1]
+        end
+      end
+
+      describe "(:limit => <number of items>)" do
+        it "should return a limited set of matching models" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user3 = create_model(user_class, :name => "Betty", :rating => 3)
+          user_adapter.find_all(:limit => 1, :order => [:rating, :asc]).should == [user1]
+          user_adapter.find_all(:limit => 2, :order => [:rating, :asc]).should == [user1, user2]
+        end
+      end
+
+      describe "(:offset => <offset number>) with limit (as DataMapper doesn't allow offset on its own)" do
+        it "should return an offset set of matching models" do
+          user1 = create_model(user_class, :name => "Fred", :rating => 1)
+          user2 = create_model(user_class, :name => "Fred", :rating => 2)
+          user3 = create_model(user_class, :name => "Betty", :rating => 3)
+          user_adapter.find_all(:limit => 3, :offset => 0, :order => [:rating, :asc]).should == [user1, user2, user3]
+          user_adapter.find_all(:limit => 3, :offset => 1, :order => [:rating, :asc]).should == [user2, user3]
+          user_adapter.find_all(:limit => 1, :offset => 1, :order => [:rating, :asc]).should == [user2]
+        end
+      end
+    end
+
+    describe "#create!(attributes)" do
+      it "should create a model with the passed attributes" do
+        user = user_adapter.create!(:name => "Fred")
+        reload_model(user).name.should == "Fred"
+      end
+
+      it "should raise error when create fails" do
+        lambda { user_adapter.create!(:user => create_model(note_class)) }.should raise_error
+      end
+
+      it "when attributes contain an associated object, should create a model with the attributes" do
+        user = create_model(user_class)
+        note = note_adapter.create!(:owner => user)
+        reload_model(note).owner.should == user
+      end
+
+      it "when attributes contain an has_many assoc, should create a model with the attributes" do
+        notes = [create_model(note_class), create_model(note_class)]
+        user = user_adapter.create!(:notes => notes)
+        reload_model(user).notes.should == notes
+      end
+    end
+
+    describe "#destroy(instance)" do
+      it "should destroy the instance if it exists" do
+        user = create_model(user_class)
+        (!!user_adapter.destroy(user)).should == true  # make it work with both RSpec 2.x and 3.x
+        user_adapter.get(user.id).should be_nil
+      end
+
+      it "should return nil if passed with an invalid instance" do
+        user_adapter.destroy("nonexistent instance").should be_nil
+      end
+
+      it "should not destroy the instance if it doesn't match the model class" do
+        user = create_model(user_class)
+        note_adapter.destroy(user).should be_nil
+        user_adapter.get(user.id).should == user
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require "rspec"
+require "couchbase/model"
+require "orm_adapter"
+require "orm_adapter-couchbase"

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: orm_adapter-couchbase
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Philipp Fehre
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: couchbase-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+- !ruby/object:Gem::Dependency
+  name: orm_adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds Couchbase support to ORM Adapter
+email:
+- philipp.fehre@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/orm_adapter-couchbase.rb
+- lib/orm_adapter-couchbase/couchbase.rb
+- lib/orm_adapter-couchbase/ext/couchbase_model_equality.rb
+- lib/orm_adapter-couchbase/ext/couchbase_model_has_many.rb
+- lib/orm_adapter-couchbase/ext/couchbase_model_patches.rb
+- lib/orm_adapter-couchbase/version.rb
+- orm_adapter-couchbase.gemspec
+- spec/couchbase_spec.rb
+- spec/design_documents/note/all/map.js
+- spec/design_documents/user/all/map.js
+- spec/design_documents/user/by_name/map.js
+- spec/design_documents/user/notes/map.js
+- spec/example_app_shared.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sideshowcoder/orm_adapter-couchbase
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Use Couchbase Model to add support for Couchbase ORM Adapter
+test_files:
+- spec/couchbase_spec.rb
+- spec/design_documents/note/all/map.js
+- spec/design_documents/user/all/map.js
+- spec/design_documents/user/by_name/map.js
+- spec/design_documents/user/notes/map.js
+- spec/example_app_shared.rb
+- spec/spec_helper.rb