couchdb 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Philipp Brüll
+
+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.rdoc

@@ -0,0 +1,47 @@
+
+= A straight-forward client for CouchDB REST API
+
+The intend of this project is to provide a plain, straight-forward abstraction of the CouchDB REST API. The resources
+exposed by the API are simply wrapped into classes.
+
+== An example
+
+  server = CouchDB::Server.new "localhost", 5984
+  database = CouchDB::Database.new server, "test"
+  database.delete_if_exists!
+  database.create_if_missing!
+
+  document_one = CouchDB::Document.new database, "_id" => "test_document_1", "category" => "one"
+  document_one.save
+
+  document_two = CouchDB::Document.new database, "_id" => "test_document_2", "category" => "two"
+  document_two.save
+
+  design = CouchDB::Design.new database, "design_1"
+  view = CouchDB::Design::View.new design, "view_1",
+    "function(document) { emit([ document['category'], document['_id'] ]); }"
+  design.save
+
+  collection = view.collection :startkey => [ "one", nil ], :endkey => [ "one", { } ]
+  collection.total_count # => 2
+  collection.size        # => 1
+  collection[0].id       # => "test_document_1"
+  collection[0].key      # => [ "one", "test_document_1" ]
+  collection[0].value    # => nil
+
+  collection.documents.include? document_one # => true
+  collection.documents.include? document_two # => false
+
+This example creates a database on the local CouchDB server (if it's missing) and stores two documents in it. It also
+creates a design document with a view, that makes it possible to select the results by the document's category.
+
+The <tt>collection</tt> call on that view, returns a subset of the results, by defining a start- and an endkey. The
+collection object itself acts as a proxy to the results. This first request of it's content will actually fetch the
+data from the server.
+
+If the results are accessed by the <tt>documents</tt> proxy, the <tt>include_docs</tt> parameter will be passed to the
+server and the delivered document hashes will be returned as an array of document (<tt>CouchDB::Document</tt>) objects.
+
+== Development
+
+This project is still under development. Any bug report and contribution is welcome!

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+gem 'rspec'
+gem 'reek'
+require 'rspec'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'reek/rake/task'
+
+task :default => :spec
+
+namespace :gem do
+
+  desc "Builds the gem"
+  task :build do
+    system "gem build *.gemspec && mkdir -p pkg/ && mv *.gem pkg/"
+  end
+
+  desc "Builds and installs the gem"
+  task :install => :build do
+    system "gem install pkg/"
+  end
+
+end
+
+Reek::Rake::Task.new do |task|
+  task.fail_on_error = true
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.add [ "README.rdoc", "lib/**/*.rb" ]
+  rdoc.main = "README.rdoc"
+  rdoc.title = ""
+end
+
+desc "Run all specs in spec directory"
+RSpec::Core::RakeTask.new do |task|
+  task.pattern = "spec/gom/**/*_spec.rb"
+end
+
+namespace :spec do
+
+  desc "Run all integration specs in spec/acceptance directory"
+  RSpec::Core::RakeTask.new(:acceptance) do |task|
+    task.pattern = "spec/acceptance/**/*_spec.rb"
+  end
+
+end

data/lib/couchdb.rb

@@ -0,0 +1,12 @@
+require 'transport'
+
+module CouchDB
+
+  autoload :Server, File.join(File.dirname(__FILE__), "couchdb", "server")
+  autoload :Database, File.join(File.dirname(__FILE__), "couchdb", "database")
+  autoload :Document, File.join(File.dirname(__FILE__), "couchdb", "document")
+  autoload :Design, File.join(File.dirname(__FILE__), "couchdb", "design")
+  autoload :Collection, File.join(File.dirname(__FILE__), "couchdb", "collection")
+  autoload :Row, File.join(File.dirname(__FILE__), "couchdb", "row")
+
+end

data/lib/couchdb/collection.rb

@@ -0,0 +1,121 @@
+
+module CouchDB
+
+  # Collection is a proxy class for the result-set of a CouchDB view. It provides
+  # all read-only methods of an array. The loading of content is lazy and
+  # will be triggered on the first request.
+  class Collection
+
+    REQUEST_PARAMETER_KEYS = [
+      :key, :startkey, :startkey_docid, :endkey, :endkey_docid,
+      :limit, :stale, :descending, :skip, :group, :group_level,
+      :reduce, :inclusive_end, :include_docs
+    ].freeze unless defined?(REQUEST_PARAMETER_KEYS)
+
+    ARRAY_METHOD_NAMES = [
+      :[], :at, :collect, :compact, :count, :cycle, :each, :each_index,
+      :empty?, :fetch, :index, :first, :flatten, :include?, :join, :last,
+      :length, :map, :pack, :reject, :reverse, :reverse_each, :rindex,
+      :sample, :shuffle, :size, :slice, :sort, :take, :to_a, :to_ary,
+      :values_at, :zip
+    ].freeze unless defined?(ARRAY_METHOD_NAMES)
+
+    attr_reader :database
+    attr_reader :url
+    attr_reader :options
+    attr_reader :documents
+
+    def initialize(database, url, options = { })
+      @database, @url, @options = database, url, options
+      @documents = DocumentsProxy.new self
+    end
+
+    def total_count
+      fetch_meta unless @total_count
+      @total_count
+    end
+
+    def respond_to?(method_name)
+      ARRAY_METHOD_NAMES.include?(method_name) || super
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if ARRAY_METHOD_NAMES.include?(method_name)
+        fetch
+        @entries.send method_name, *arguments, &block
+      else
+        super
+      end
+    end
+
+    private
+
+    def fetch
+      fetch_response
+      evaluate_total_count
+      evaluate_entries
+      true
+    end
+
+    def fetch_meta
+      fetch_meta_response
+      evaluate_total_count
+      true
+    end
+
+    def fetch_response
+      @response = Transport::JSON.request(
+        :get, url,
+        :parameters => request_parameters,
+        :expected_status_code => 200,
+        :encode_parameters => true
+      )
+    end
+
+    def fetch_meta_response
+      @response = Transport::JSON.request(
+        :get, url,
+        :parameters => request_parameters.merge(:limit => 0),
+        :expected_status_code => 200,
+        :encode_parameters => true
+      )
+    end
+
+    def request_parameters
+      parameters = { }
+      REQUEST_PARAMETER_KEYS.each do |key|
+        parameters[key] = @options[key] if @options.has_key?(key)
+      end
+      parameters
+    end
+
+    def evaluate_total_count
+      @total_count = @response["total_rows"]
+    end
+
+    def evaluate_entries
+      @entries = (@response["rows"] || [ ]).map{ |row_hash| Row.new @database, row_hash }
+    end
+
+    # A proxy class for the collection's fetched documents.
+    class DocumentsProxy
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if ARRAY_METHOD_NAMES.include?(method_name)
+          @collection.options[:include_docs] = true
+          @documents = @collection.map{ |row| row.document }
+          @documents.send method_name, *arguments, &block
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/couchdb/database.rb

@@ -0,0 +1,57 @@
+
+module CouchDB
+
+  # The Database class provides methods create, delete and retrieve informations
+  # of a CouchDB database.
+  class Database
+
+    attr_reader :server
+    attr_reader :name
+
+    def initialize(server, name)
+      @server, @name = server, name
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @name == other.name && @server == other.server
+    end
+
+    def ===(other)
+      object_id == other.object_id
+    end
+
+    def create!
+      Transport::JSON.request :put, url, :expected_status_code => 201
+    end
+
+    def create_if_missing!
+      create! unless exists?
+    end
+
+    def delete!
+      Transport::JSON.request :delete, url, :expected_status_code => 200
+    end
+
+    def delete_if_exists!
+      delete! if exists?
+    end
+
+    def information
+      Transport::JSON.request :get, url, :expected_status_code => 200
+    end
+
+    def exists?
+      @server.database_names.include? @name
+    end
+
+    def url
+      "#{@server.url}/#{@name}"
+    end
+
+    def documents(options = { })
+      Collection.new self, url + "/_all_docs", options
+    end
+
+  end
+
+end

data/lib/couchdb/design.rb

@@ -0,0 +1,57 @@
+
+module CouchDB
+
+  # The Design class acts as a wrapper for CouchDB design documents.
+  class Design < Document
+
+    autoload :View, File.join(File.dirname(__FILE__), "design", "view")
+
+    attr_accessor :language
+    attr_reader :views
+
+    def initialize(database, id, language = "javascript")
+      super database
+      self.id, self.language = id, language
+      @views = ViewsProxy.new self
+    end
+
+    def id
+      super.sub /^_design\//, ""
+    end
+
+    def id=(value)
+      super "_design/#{value}"
+    end
+
+    def language
+      self["language"]
+    end
+
+    def language=(value)
+      self["language"] = value
+    end
+
+    private
+
+    # A proxy class for the views property.
+    class ViewsProxy
+
+      def initialize(design)
+        @design = design
+        @design["views"] = { }
+      end
+
+      def <<(view)
+        @design["views"].merge! view.to_hash
+      end
+
+      def [](name)
+        map, reduce = @design["views"][name].values_at("map", "reduce")
+        Design::View.new name, map, reduce
+      end
+
+    end
+
+  end
+
+end

data/lib/couchdb/design/view.rb

@@ -0,0 +1,37 @@
+
+module CouchDB
+
+  # See CouchDB::Design class for description.
+  class Design < Document
+
+    # The View class acts as a wrapper for the views that are in the CouchDB design document. It also
+    # provides methods to generate simple view javascript functions.
+    class View
+
+      attr_accessor :design
+      attr_accessor :name
+      attr_accessor :map
+      attr_accessor :reduce
+
+      def initialize(design, name, map = nil, reduce = nil)
+        @design, @name, @map, @reduce = design, name, map, reduce
+        @design.views << self
+      end
+
+      def to_hash
+        { @name => { "map" => @map, "reduce" => @reduce } }
+      end
+
+      def collection(options = { })
+        @design ? Collection.new(@design.database, url, options) : nil
+      end
+
+      def url
+        @design ? "#{@design.url}/_view/#{@name}" : nil
+      end
+
+    end
+
+  end
+
+end

data/lib/couchdb/document.rb

@@ -0,0 +1,127 @@
+
+module CouchDB
+
+  # Base is the main super class of all models that should be stored in CouchDB.
+  # See the README file for more information.
+  class Document
+
+    # The NotFoundError will be raised if an operation is tried on a document that
+    # doesn't exists.
+    class NotFoundError < StandardError; end
+
+    attr_reader :database
+
+    def initialize(database, properties = { })
+      @database = database
+      @properties = properties
+    end
+
+    def [](key)
+      @properties[key.to_s]
+    end
+
+    def []=(key, value)
+      @properties[key.to_s] = value
+    end
+
+    def id
+      self["_id"]
+    end
+
+    def id=(value)
+      self["_id"] = value
+    end
+
+    def rev
+      self["_rev"]
+    end
+
+    def rev=(value)
+      self["_rev"] = value
+    end
+
+    def rev?
+      @properties.has_key? "_rev"
+    end
+
+    def clear_rev
+      @properties.delete "_rev"
+    end
+
+    def ==(other)
+      self.id == other.id
+    end
+
+    def new?
+      !self.rev?
+    end
+
+    def exists?
+      Transport::JSON.request :get, url, :expected_status_code => 200
+      true
+    rescue Transport::UnexpectedStatusCodeError => error
+      raise error unless error.status_code == 404
+      false
+    end
+
+    def load
+      @properties = Transport::JSON.request :get, url, :expected_status_code => 200
+      true
+    rescue Transport::UnexpectedStatusCodeError => error
+      upgrade_unexpected_status_error error
+    end
+    alias reload load
+
+    def save
+      new? ? create : update
+    end
+
+    def destroy
+      return false if new?
+      Transport::JSON.request :delete, url, :headers => { "If-Match" => self.rev }, :expected_status_code => 200
+      self.clear_rev
+      true
+    rescue Transport::UnexpectedStatusCodeError => error
+      upgrade_unexpected_status_error error
+    end
+
+    def url
+      "#{self.database.url}/#{self.id}"
+    end
+
+    private
+
+    def create
+      response = Transport::JSON.request :post, @database.url, :body => @properties, :expected_status_code => 201
+      self.id  = response["id"]
+      self.rev = response["rev"]
+      true
+    rescue Transport::UnexpectedStatusCodeError
+      false
+    end
+
+    def update
+      response = Transport::JSON.request :put, url, :body => @properties, :expected_status_code => 201
+      self.rev = response["rev"]
+      true
+    rescue Transport::UnexpectedStatusCodeError
+      false
+    end
+
+    def upgrade_unexpected_status_error(error)
+      raise NotFoundError if error.status_code == 404
+      raise error
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      @properties.send method_name, *arguments, &block
+    end
+
+    def self.create(*arguments)
+      model = new *arguments
+      model.save ? model : nil
+    end
+
+  end
+
+end