slipcover 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad54f411cbdcf51d91104e6a64a0ab1e3b5e8c47
+  data.tar.gz: 5a438e303c5409b40a23ff201fa9559b50d73bc9
+SHA512:
+  metadata.gz: 0115fb08c97b683454d17a889c2506aabc017627007e60b57bb937c2aae9ebc4b6d216be24e28a6cb7cdc383b180bb1b8f23fb73a5e559f6eb51210d5b862dcb
+  data.tar.gz: 5327028a2b60a08526415b984d037ad0d04abfbf3ba6cc6cceae41df754415b4f460f40ae8977ee872ee3047ac34f4c49dc3883e2aaf950c7ba7470faa665c07

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/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-2.0.0@slipcover --create

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 socialchorus
+
+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,96 @@
+# Slipcover
+
+Slipcover is a really lite wrapper around CouchDB. It comes with a Railtie to get your Rails app setup fast.
+It is YAML configured allowing easy connection to servers, without imposing database constraints ... since
+one of the best parts of CouchDB is the ease at which you can create new databases.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'slipcover'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install slipcover
+
+## Usage
+
+### With Rails
+Put a `slipcover.yml` in your config directory. Here is a sample:
+
+    development:
+      host: 127.0.0.1
+      port: 5984
+
+    production:
+      host: socialcoders.couchservice.com
+      username: username
+      password: password
+
+#### Create a database:
+
+    Slipcover::Database.new('my_database_name').create
+
+This will create a database with the Rails environment appended to the back of it: `database_name_development`.
+This is a great convenience for testing etc, since you can create many database on the fly and they won't conflict
+with development or other databases of the same name.
+
+#### Create some documents:
+
+    doc = Slipcover::Document.new('my_database_name', {foo: ['a', 'row', 'of', 'bars']})
+    doc.save
+
+#### Write views is js to query them:
+
+Create a directory inside the Rails app called: `slipcover_views`. Organize each view/index in its own directory with a `map.js`
+file. Where appropriate also add a `reduce.js` function. Since these files are real js files, they can be tested via Jasmine,
+or your favorite testing framework.
+
+#### Put a design document in your database to capture these views/indexes
+
+    design_doc = Slipcover::DesignDocument.new('my_database_name', 'design_it_good')
+    design_doc.save
+
+It constructs views from the default app/slipcover_views directory. If you want to customize where the views live, do some
+dependency injection:
+
+    design_doc = Slipcover::DesignDocument.new('my_database_name', 'degign_it_good', my_custom_directory)
+    design_doc.save
+
+#### Query Data
+
+    desgin_document = Slipcover::DesignDocument.new('my_database_name', 'degign_it_good')
+    query = Slipcover::Query.new(design_document, view_name)
+    query.all
+    query.all(key: 'foo')
+
+### Usages Sans-Rails
+
+Put a YAML configuration file where it seems appropriate. Configure slipcover so that it knows where your YAML is:
+
+    Slipcover::Config.yaml_path = my_special_place
+
+Let Slipcover know what environment your are operating under:
+
+    Slipcover.env = 'staging'
+
+When constructing databases, Slipcover will use your yaml and environmental configuration to setup the right server.
+
+If you are looking for more freedom, you can created databases with an optional second argument that is a server.
+
+The slipcover views can also be put wherever you want and configured in at the Slipcover::Config level or the individual
+design document.
+
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/slipcover.rb

@@ -0,0 +1,15 @@
+require 'json'
+require 'rest-client'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/module/delegation'
+
+require "slipcover/version"
+require "slipcover/http_adapter"
+require "slipcover/server"
+require "slipcover/config"
+require "slipcover/database"
+require "slipcover/document"
+require "slipcover/design_document"
+require "slipcover/query"
+
+require 'slipcover/railtie' if defined?(Rails)

data/lib/slipcover/config.rb

@@ -0,0 +1,22 @@
+module Slipcover
+  class Config
+    class << self
+      attr_accessor :view_dir, :yaml_path
+      attr_writer :env, :server
+    end
+
+    def self.env
+      @env ||= ENV['RACK_ENV'] || 'development'
+    end
+
+    def self.server
+      @server ||= Server.new(yaml_path, env)
+    end
+
+    def self.rails!
+      self.env = Rails.env
+      self.yaml_path = Rails.root.join('config/slipcover.yml')
+      self.view_dir = Rails.root.join("/app/slipcover_views")
+    end
+  end
+end

data/lib/slipcover/database.rb

@@ -0,0 +1,40 @@
+module Slipcover
+  class Database
+    attr_reader :name, :server
+
+    def initialize(name, server=nil)
+      @name = name
+      @server = server || Slipcover::Config.server
+    end
+
+    def url
+      "#{server.url}/#{name}_#{Slipcover::Config.env}"
+    end
+
+    def http_adapter
+      @http_adapter ||= HttpAdapter.new
+    end
+
+    delegate :get, :post, :put,
+      to: :http_adapter
+
+    def create
+      put(url)
+    rescue HttpAdapter::Conflict
+      # handled by the ensure, move along
+    ensure
+      return info
+    end
+
+    def delete
+      http_adapter.delete(url)
+      true
+    rescue Exception => e
+      false
+    end
+
+    def info
+      get(url)
+    end
+  end
+end

data/lib/slipcover/design_document.rb

@@ -0,0 +1,57 @@
+module Slipcover
+  class DesignDocument
+    attr_reader :database_name, :name, :view_dir
+
+    def initialize(database_name, name, view_dir=nil)
+      @database_name = database_name
+      @name = name
+      @view_dir = view_dir || Slipcover::Config.view_dir
+    end
+
+    def document
+      @document ||= Document.new(database_name, {
+        id: document_id,
+        language: 'javascript',
+        views: views
+      })
+    end
+
+    delegate :url, :attributes, :id, :rev, :delete, :database,
+      to: :document
+
+    def fetch
+      document.fetch
+      document.attributes[:views].symbolize_keys!
+      document.attributes[:views].each {|key, hash| document.attributes[:views][key] = hash.symbolize_keys!}
+      document
+    end
+
+    def save
+      document.save
+    rescue HttpAdapter::ConflictError
+      document.fetch
+      document[:views] = views
+      document.save
+    end
+
+    def document_id
+      "_design/#{name}"
+    end
+
+    def [](key)
+      document[:views][key]
+    end
+
+    def views
+      Dir.entries(view_dir).inject({}) do |hash, path|
+        if !path.match(/\./)
+          dir = view_dir + "/" + path
+          hash[path.to_sym] ||= {}
+          hash[path.to_sym][:map] = File.read(dir + "/map.js")
+          hash[path.to_sym][:reduce] = File.read(dir + "/reduce.js") if File.exist?(dir + "/reduce.js")
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/slipcover/document.rb

@@ -0,0 +1,77 @@
+module Slipcover
+  class Document
+    attr_accessor :attributes, :id, :rev
+    attr_reader :database_name
+
+    def initialize(database_name, attributes={})
+      @database_name = database_name
+      self.attributes = attributes.symbolize_keys
+      set_intrinsic_values
+    end
+
+    delegate :[], :[]=, to: :attributes
+
+    def http_adapter
+      @http_adapter ||= HttpAdapter.new
+    end
+
+    delegate :get, :post, :put,
+      to: :http_adapter
+
+    def save
+      http_method = id ? :put : :post
+      doc_url = id ? url : database.url
+
+      response = send(http_method, doc_url, attributes_for_save)
+      set_intrinsic_values(response)
+    end
+
+    def fetch
+      self.attributes = get(url)
+      set_intrinsic_values
+    end
+
+    def delete
+      http_adapter.delete("#{url}?rev=#{rev}")
+      set_intrinsic_values({})
+      nullify_intrinsic_attributes
+      true
+    rescue Exception => e
+      false
+    end
+
+    def url
+      raise ArgumentError.new('no document id') unless id
+      "#{database.url}/#{id}"
+    end
+
+    def database
+      return @database if @database
+      @database = Slipcover::Database.new(database_name)
+      @database.create
+      @database
+    end
+
+    private
+
+    def attributes_for_save
+      attrs = attributes.clone
+      attrs[:_rev] = rev if rev
+      attrs[:_id]  = id if id
+      attrs
+    end
+
+    def set_intrinsic_values(attrs=nil)
+      attrs ||= attributes
+      self.id =   attrs[:id] || attrs[:_id]
+      self.rev =  attrs[:rev] || attrs[:_rev]
+    end
+
+    def nullify_intrinsic_attributes
+      attributes[:_id] = nil
+      attributes[:id] = nil
+      attributes[:_rev] = nil
+      attributes[:rev] = nil
+    end
+  end
+end

data/lib/slipcover/http_adapter.rb

@@ -0,0 +1,74 @@
+module Slipcover
+  class HttpAdapter
+    def get(url, data={})
+      try {
+        parse( RestClient.get(url + query_string(data), headers) )
+      }
+    end
+
+    def post(url, data={})
+      try {
+        parse( RestClient.post(url, data.to_json, headers) )
+      }
+    end
+
+    def put(url, data={})
+      try {
+        parse( RestClient.put(url, data.to_json, headers) )
+      }
+    end
+
+    def delete(url, data={})
+      try {
+        parse( RestClient.delete(url + query_string(data), headers) )
+      }
+    end
+
+    def query_string(data)
+      return "" if data.empty?
+      
+      query = data.map do |key, value|
+        "#{key}=#{value}"
+      end.join("&")
+
+      "?#{query}"
+    end
+
+    def parse(response)
+      JSON.parse(response).symbolize_keys
+    end
+
+    def try
+      yield
+    rescue Exception => e
+      reraise(e)
+    end
+
+    def reraise(e)
+      raise error_class(e).new(e.message)
+    end
+
+    def error_class(e)
+      {
+        JSON::ParserError => ParseError,
+        RestClient::ResourceNotFound => NotFound,
+        RestClient::PreconditionFailed => ConflictError,
+        RestClient::Conflict => ConflictError
+
+      }[e.class] || e.class
+    end
+
+    class ConflictError < RuntimeError
+    end
+
+    class ParseError < RuntimeError
+    end
+
+    class NotFound < RuntimeError
+    end
+
+    def headers
+      {:content_type => :json, :accept => :json}
+    end
+  end
+end

data/lib/slipcover/query.rb

@@ -0,0 +1,45 @@
+module Slipcover
+  class Query
+    attr_reader :design_document, :view_name
+
+    def initialize(design_document, view_name)
+      @design_document = design_document
+      @view_name = view_name
+    end
+
+    def http_adapter
+      @http_adapter ||= HttpAdapter.new
+    end
+
+    delegate :get,
+      to: :http_adapter
+
+    def url
+      "#{design_document.url}/_view/#{view_name}" # todo adapter takes opts and converts to query string
+    end
+
+    def all(opts={})
+      get(url, repackage(opts))[:rows].map{|row| Document.new(database.name, row['doc'].symbolize_keys) }
+    end
+
+    def repackage(opts)
+      opts.each do |key, value|
+        opts[key] = escape(value) if escape_key?(key)
+      end
+
+      {include_docs: true}.merge(opts)
+    end
+
+    def database
+      design_document.database
+    end
+
+    def escape(value)
+      URI.escape(value.inspect)
+    end
+
+    def escape_key?(key)
+      [:key, :keys, :startkey, :startkey_docid, :endkey, :endkey_docid, :stale].include?(key.to_sym)
+    end
+  end
+end

data/lib/slipcover/railtie.rb

@@ -0,0 +1,7 @@
+module Slipcover
+  class Railtie < Rails::Railtie
+    initializer "slipcover.configure_rails_initialization" do
+      Slipcover::Config.rails!
+    end
+  end
+end

data/lib/slipcover/server.rb

@@ -0,0 +1,30 @@
+module Slipcover
+  class Server < Struct.new(:path, :key)
+    def server_configs
+      YAML.load(File.read(path))
+    end
+
+    def config
+      @config ||= server_configs[key]
+    end
+
+    def url
+      "#{user_info}#{host}#{port}"
+    end
+
+    def user_info
+      info = config['username'] || ""
+      info << ":#{config['password']}" if config['password']
+      info << "@" unless info.empty?
+      info
+    end
+
+    def host
+      config['host']
+    end
+
+    def port
+      config['port'] ? ":#{config['port']}" : ''
+    end
+  end
+end

data/lib/slipcover/version.rb

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

data/slipcover.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'slipcover/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "slipcover"
+  spec.version       = Slipcover::VERSION
+  spec.authors       = ["Kane Baccigalupi", "Deepti Anand", "Fito von Zastow", 'SocialCoders @ SocialChorus']
+  spec.email         = ["baccigalupi@gmail.com", "developers@socialchorus.com"]
+  spec.description   = %q{Lite wrapper for CouchDB}
+  spec.summary       = %q{Lite wrapper for CouchDB}
+  spec.homepage      = "http://github.com/socialchorus/slipcover"
+  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 "rest-client"
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+end

data/spec/database_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Slipcover::Database, 'functional to the Slipcover database' do
+  let(:database) { Slipcover::Database.new(name, server) }
+  let(:name) { 'database_name' }
+  let(:server) { Slipcover::Server.new(File.dirname(__FILE__) + "/support/slipcover.yml", 'development') }
+  let(:database_url) { "#{database.server.url}/database_name_development" }
+
+  def ensure_database
+    RestClient.delete(database_url) rescue nil
+    RestClient.put(database_url, {}.to_json, {:content_type => :json, :accept => :json})
+  end
+
+  after do
+    RestClient.delete(database_url) rescue nil
+  end
+
+  describe '#info' do
+    before do
+      ensure_database
+    end
+
+    it "return information about the database" do
+      info = database.info
+      info.should be_a(Hash)
+      info.keys.should include(:doc_count)
+    end
+  end
+
+  describe "#create" do
+    context 'database does not exist' do
+      before do
+        RestClient.delete(database_url) rescue nil
+      end
+
+      it 'creates the database' do
+        info = database.create
+        info.should be_a(Hash)
+        info.keys.should include(:doc_count)
+      end
+    end
+
+    context 'database already exists' do
+      before do
+        ensure_database
+      end
+
+      it 'returns info about the existing database' do
+        info = database.create
+        info.should be_a(Hash)
+        info.keys.should include(:doc_count)
+      end
+    end
+  end
+
+  describe "#delete" do
+    context 'database exists' do
+      before do
+        ensure_database
+      end
+
+      it "deletes the database" do
+        database.delete.should == true
+
+        expect {
+          database.info
+        }.to raise_error( Slipcover::HttpAdapter::NotFound )
+      end
+    end
+
+    context 'database does not exist' do
+      before do
+        RestClient.delete(database_url) rescue nil
+      end
+
+      it "returns false" do
+        database.delete.should == false
+      end
+    end
+  end
+end

data/spec/design_document_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Slipcover::DesignDocument do
+  let(:document) { Slipcover::DesignDocument.new(database_name, name, view_dir) }
+  let(:database_name) { 'design_me' }
+  let(:database) { Slipcover::Database.new(database_name) }
+  let(:name) { 'designation' }
+  let(:view_dir) { support_dir + "/slipcover_views" }
+
+  let(:support_dir) { File.dirname(__FILE__) + "/support" }
+  let(:map_function) { File.read(view_dir + "/by_name/map.js") }
+
+  before do
+    database.delete
+    database.create
+  end
+
+  it "defaults to javascript as a language" do
+    document.attributes[:language].should == 'javascript'
+  end
+
+  it "has the right url" do
+    document.url.should == "#{database.url}/_design/designation"
+  end
+
+  describe 'views' do
+    it "finds them via the mapping of the name to the view directory" do
+      document[:by_name][:map].should == map_function
+    end
+  end
+
+  describe '#save' do
+    context "when the design document does not yet exist" do
+      it "saves it and delegates good stuff to it" do
+        document.save
+        document.fetch
+        document[:by_name][:map].should == map_function
+        document.id.should_not be_nil
+        document.rev.should_not be_nil
+      end
+    end
+
+    context 'when the design document already exists' do
+      it "updates it without raising an error" do
+        document.save
+
+        duplicate_document = Slipcover::DesignDocument.new(database_name, name, view_dir)
+
+        duplicate_document.save
+        duplicate_document.rev.should_not be_nil
+
+        # expect { duplicate_document.save }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/document_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Slipcover::Document, 'functional' do
+  let(:document) { Slipcover::Document.new(database_name, attributes) }
+  let(:database) { Slipcover::Database.new(database_name) }
+  let(:database_name) { 'hello_database' }
+  let(:attributes) {
+    {
+      type: 'foo',
+      author: 'something'
+    }
+  }
+
+  before do
+    Slipcover::Config.server ||= Slipcover::Server.new(File.dirname(__FILE__) + "/support/slipcover.yml", 'development')
+    database.create
+  end
+
+  after do
+    database.delete
+  end
+
+  describe '#initialize' do
+    let(:attributes) {
+      {
+        id: '298c2fd111c14633e445ef818b039ff3-us',
+        rev: '2-298c2fd111c14633e445ef818b039ff3',
+        type: 'foo',
+        author: 'something'
+      }
+    }
+
+    it "has an id" do
+      document.id.should == attributes[:id]
+    end
+
+    it "has a rev" do
+      document.rev.should == attributes[:rev]
+    end
+  end
+
+  describe '#fetch' do
+    before do
+      document.save
+      document.rev = nil
+      document.attributes = {}
+      document.fetch
+    end
+
+    it "should return all the attributes" do
+      document.attributes[:type].should == 'foo'
+      document.attributes[:author].should == 'something'
+    end
+
+    it "should update the rev" do
+      document.fetch
+      document.rev.should_not be_nil
+    end
+
+    it 'should raise an error if id does not exist' do
+      document.id = nil
+      expect{ document.fetch }.to raise_error
+    end
+  end
+
+  describe '#save' do
+    context 'when there is no id' do
+      before do
+        document.save
+      end
+
+      it "gets the id from the server response" do
+        document.id.should_not be_nil
+      end
+
+      it "gets the rev from the server response" do
+        document.rev.should_not be_nil
+      end
+
+      it 'should maintains its local attributes' do
+        document.attributes[:type].should == 'foo'
+        document.attributes[:author].should == 'something'
+      end
+
+      it "is stored in the database, and available" do
+        expect {
+          RestClient.get(document.url)
+        }.not_to raise_error
+        document.fetch
+        document.attributes[:type].should == 'foo'
+      end
+    end
+
+    context 'when there is an id passed in' do
+      before do
+        document.save
+        document.attributes[:bar] = 'what?'
+      end
+
+      it 'gets a new revision' do
+        original_rev = document.rev.clone
+        document.save
+        document.rev.should_not == original_rev
+      end
+
+      it 'updates the database' do
+        document.save
+        document.fetch
+        document.attributes[:bar].should == 'what?'
+      end
+
+      it "does not create another document" do
+        document.database.info[:doc_count].should == 1
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when the document is on the server' do
+      before do
+        document.save
+        document[:_rev] = '_rev'
+        document[:rev] = 'rev'
+        document[:_id] = '_id'
+        document[:id] = 'id'
+      end
+
+      it 'should delete the record from the database' do
+        url = document.url
+        document.delete
+        expect {
+          RestClient.get(url)
+        }.to raise_error
+      end
+
+      it "should return true" do
+        document.delete.should == true
+      end
+
+      it 'should clear the id and rev' do
+        document.delete
+        document.id.should be_nil
+        document.rev.should be_nil
+        document[:_id].should be_nil
+        document[:id].should be_nil
+        document[:_rev].should be_nil
+        document[:rev].should be_nil
+      end
+    end
+
+    context 'when the document is not on the sever' do
+      it "should return false" do
+        document.delete.should == false
+      end
+    end
+  end
+end

data/spec/http_adapter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Slipcover::HttpAdapter do
+  let(:adapter) { Slipcover::HttpAdapter.new }
+
+
+  describe '#get' do
+    let(:response) { {}.to_json }
+
+    before do
+      RestClient.stub(:get).and_return(response)
+    end
+
+    it "should package up data into a query string" do
+      RestClient.should_receive(:get).with('http://url.com?foo=bar', anything).and_return(response)
+      adapter.get('http://url.com', {foo: 'bar'})
+    end
+  end
+
+  describe '#delete' do
+    let(:response) { {}.to_json }
+
+    before do
+      RestClient.stub(:delete).and_return(response)
+    end
+
+    it "should package up data into a query string" do
+      RestClient.should_receive(:delete).with('http://url.com?foo=bar', anything).and_return(response)
+      adapter.delete('http://url.com', {foo: 'bar'})
+    end
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Slipcover::Query do
+  let(:query) { Slipcover::Query.new(design_document, :by_name) }
+  let(:design_document) { Slipcover::DesignDocument.new(database_name, name, view_dir) }
+
+  let(:database_name)   { 'my_database_name' }
+  let(:name)            { 'designation' }
+  let(:view_dir)        { support_dir + "/slipcover_views" }
+  let(:support_dir)     { File.dirname(__FILE__) + "/support" }
+
+  before do
+    db = Slipcover::Database.new(database_name)
+    db.delete
+    db.create
+
+    design_document.save
+
+    Slipcover::Document.new(database_name, {name: 'Deepti'}).save
+    Slipcover::Document.new(database_name, {name: 'Fito'}).save
+    Slipcover::Document.new(database_name, {name: 'Kane'}).save
+    Slipcover::Document.new(database_name, {animal: 'gerbil'}).save
+  end
+
+  after do
+    db = Slipcover::Database.new(database_name)
+    db.delete
+  end
+
+  describe '#all' do
+    it 'returns all the documents that match the index/view' do
+      results = query.all
+      results.size.should == 3
+      results.map {|doc| doc[:name] }.should =~ ['Deepti', 'Fito', 'Kane']
+    end
+
+    context 'with options' do
+      context 'with key' do
+        it "returns only the related records" do
+          results = query.all({key: 'Deepti'})
+          results.size.should == 1
+          results.first[:name].should == 'Deepti'
+        end
+      end
+
+      context 'with a startkey and endkey' do
+        it "return the range of docs" do
+          results = query.all({startkey: 'Da', endkey: 'Fz'})
+          results.size.should == 2
+          results.map{ |doc| doc[:name] }.should =~ ['Deepti', 'Fito']
+        end
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Slipcover::Server do
+  let(:server) { Slipcover::Server.new(config_path, env) }
+  let(:config_path) { File.dirname(__FILE__) + "/support/slipcover.yml" }
+  let(:env) { 'development' }
+
+  context "when the host is a local address" do
+    describe "#url" do
+      it 'returns the right url' do
+        server.url.should == "127.0.0.1:5984"
+      end
+    end
+  end
+
+  context "when the host is a remote address" do
+    let(:env) { 'production' }
+    describe "#url" do
+      it 'returns the right url' do
+        server.url.should == "username:password@socialcoders.couchserver.com"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+$: << File.dirname(__FILE__) + "/../lib"
+require 'slipcover'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before do
+    Slipcover::Config.yaml_path = File.dirname(__FILE__) + "/support/slipcover.yml"
+  end
+end

data/spec/support/slipcover.yml

@@ -0,0 +1,8 @@
+development:
+  host: 127.0.0.1
+  port: 5984
+
+production:
+  host: socialcoders.couchserver.com
+  username: username
+  password: password

data/spec/support/slipcover_views/by_name/map.js

@@ -0,0 +1,3 @@
+function (doc) {
+  if (doc.name) emit(doc.name);
+}

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: slipcover
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kane Baccigalupi
+- Deepti Anand
+- Fito von Zastow
+- SocialCoders @ SocialChorus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Lite wrapper for CouchDB
+email:
+- baccigalupi@gmail.com
+- developers@socialchorus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/slipcover.rb
+- lib/slipcover/config.rb
+- lib/slipcover/database.rb
+- lib/slipcover/design_document.rb
+- lib/slipcover/document.rb
+- lib/slipcover/http_adapter.rb
+- lib/slipcover/query.rb
+- lib/slipcover/railtie.rb
+- lib/slipcover/server.rb
+- lib/slipcover/version.rb
+- slipcover.gemspec
+- spec/database_spec.rb
+- spec/design_document_spec.rb
+- spec/document_spec.rb
+- spec/http_adapter_spec.rb
+- spec/query_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
+- spec/support/slipcover.yml
+- spec/support/slipcover_views/by_name/map.js
+homepage: http://github.com/socialchorus/slipcover
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Lite wrapper for CouchDB
+test_files:
+- spec/database_spec.rb
+- spec/design_document_spec.rb
+- spec/document_spec.rb
+- spec/http_adapter_spec.rb
+- spec/query_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
+- spec/support/slipcover.yml
+- spec/support/slipcover_views/by_name/map.js