dm-couchdb-adapter 0.10.2

data/Gemfile

@@ -0,0 +1 @@
+source "http://rubygems.org"

data/History.txt

@@ -0,0 +1,33 @@
+=== 0.9.10 / 2009-01-19
+
+* 2 minor enhancements:
+
+  * Confirmed upload feature working
+  * Implemented multi-key fetch
+  * Return a Hash instead of Struct increasing performance
+
+* 4 bug fixes:
+
+  * Fixed conflict with to_json from dm-serializer
+  * Stop escaping the slash in auto_migrate to match new CouchDB
+    behavior
+  * Fixed lazy evaluation of views
+  * Internal fixes for CouchDB r731863
+
+=== 0.9.9 / 2009-01-04
+
+* 1 bug fix:
+
+  * Escape the slash in destroy_model_storage
+
+=== 0.9.8 / 2008-12-07
+
+* 1 minor enhancement:
+
+  * Correct parsing of a params hash
+
+* 3 bug fixes:
+
+  * Correct escaping of view and attachment URLs
+  * couch adapter name no longer mandated
+  * Correct content type now sent

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kabari Hendrick
+
+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/Manifest.txt

@@ -0,0 +1,21 @@
+.gitignore
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+TODO
+lib/couchdb_adapter.rb
+lib/couchdb_adapter/attachments.rb
+lib/couchdb_adapter/couch_resource.rb
+lib/couchdb_adapter/json_object.rb
+lib/couchdb_adapter/version.rb
+lib/couchdb_adapter/view.rb
+spec/couchdb_adapter_spec.rb
+spec/couchdb_attachments_spec.rb
+spec/couchdb_view_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/testfile.txt
+tasks/install.rb
+tasks/spec.rb

data/README.rdoc

@@ -0,0 +1,68 @@
+This is a datamapper adapter to couchdb.
+
+NOTE: some functionality and their specs are based on functionality that is in
+edge couch but not in stable.  If you want everything to work, use edge.
+Otherwise, your milage may vary.  Good luck and let me know about any bugs.
+
+== Setup
+Install with the rest of the dm-more package, using:
+  gem install dm-more
+
+Setting up:
+  The easiest way is to pass a full url, here is an example:
+  "couchdb://localhost:5984/my_app_development"
+
+  You can break it out like this:
+  "#{adapter}://#{host}:#{port}/#{database}"
+  - adapter should be :couchdb
+  - database (should be the name of your database)
+  - host (probably localhost)
+  - port should be specified (couchdb defaults to port 5984)
+
+If you haven't you'll need to create this database.
+The easiest way is with curl in the terminal, like so:
+'curl -X PUT localhost:5984/my_app_development'
+You should use the same address here as you did to connect (just leave out the 'couchdb://' part)
+
+Now, if you want to have a model stored in couch you can just use:
+include DataMapper::CouchResource
+instead of the normal:
+include DataMapper::Resource
+
+This adds the following reserved properties (which have special meaning in Couch, so don't overwrite them):
+property :id, String, :key => true, :field => '_id'
+property :rev, String, :field => '_rev'
+property :attachments, DataMapper::Types::JsonObject, :field => '_attachments'
+
+If you want the model to use your couch repository by default, be sure to also add the following(replacing :couch with your repository name):
+def self.default_repository_name
+  :couch
+end
+
+You should now be able to use resources and their properties and have them stored to couchdb.
+NOTE: 'couchdb_type' is a reserved property, used to map documents to their ruby models.
+
+== Views
+Special consideration has been made to work with CouchDB views.
+You should do ALL queries you'll be repeating this way, doing 'User.all(:something => 'this)' will work, but it is much slower and more inefficient than running views you already created.
+You define them in the model with the view function and use Model.auto_migrate! to add the views for that Model to the database, or DataMapper.auto_migrate! to add the views for all models to the database.
+
+An example class with views:
+
+class User
+  include DataMapper::Resource
+
+  property :name, String
+  view(:by_name_only_this_model) {{ "map" => "function(doc) { if (doc.couchdb_type == 'User') { emit(doc.name, doc); } }" }}
+  view(:by_name_with_descendants) {{ "map" => "function(doc) { if (#{couchdb_types_condition}) { emit(doc.name, doc); } }" }}
+end
+
+couchdb_types_condition builds a condition for you if you want a view that checks to see if the couchdb_type of the record is that of the current model or any of its descendants, just load your models and run Model.couchdb_types_condition and copy/paste the output as the condition in the models view.  I will be making this smoother/cleaner, as I need to reimplement view handling.
+
+You could then call User.by_name to get a listing of users ordered by name, or pass a key to try and find a specific user by their name, ie User.by_name(:key => 'username').
+
+# TODO: add details about other view options
+
+== Example
+For a working example of this functionality checkout muddle, my merb based tumblelog, which uses this adapter to save its posts, at:
+http://github.com/geemus/muddle

data/Rakefile

@@ -0,0 +1,65 @@
+require 'pathname'
+require 'rubygems'
+require "rake"
+
+ROOT    = Pathname(__FILE__).dirname.expand_path
+JRUBY   = RUBY_PLATFORM =~ /java/
+WINDOWS = Gem.win_platform?
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+require ROOT + 'lib/couchdb_adapter/version'
+
+GEM_NAME = 'dm-couchdb-adapter'
+GEM_VERSION = DataMapper::CouchDBAdapter::VERSION
+GEM_DEPENDENCIES = [['dm-core', "~>#{GEM_VERSION}"], ['mime-types', '~>1.15']]
+GEM_CLEAN = %w[ log pkg coverage ]
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
+
+
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = GEM_NAME
+    gem.summary = %Q{CouchDB Adapter for DataMapper}
+    gem.email = 'kabari [a] gmail [d] com'
+    gem.homepage = "http://github.com/kabari/#{GEM_NAME}/tree/master"
+    gem.authors = ["Kabari Hendrick"]
+    # gem is a Gem::Specification... see 
+    #  for additional settings
+    gem.required_ruby_version = '>= 1.8.6'
+    gem.add_dependency("extlib", ">= 0.9.11")
+    gem.add_dependency('mime-types', '~>1.15')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+  spec.fail_on_error = false
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{GEM_NAME} #{GEM_VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include("LICENSE") 
+  rdoc.rdoc_files.include("TODO") 
+  rdoc.rdoc_files.include("History.txt")
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.10.2

data/lib/couchdb_adapter/adapter.rb

@@ -0,0 +1,165 @@
+module DataMapper
+  module Adapters
+    class CouchDBAdapter < AbstractAdapter
+      ConnectionError = Class.new(StandardError)
+      
+      # Persists one or many new resources
+      #
+      # @example
+      #   adapter.create(collection)  # => 1
+      #
+      # Adapters provide specific implementation of this method
+      #
+      # @param [Enumerable<Resource>] resources
+      #   The list of resources (model instances) to create
+      #
+      # @return [Integer]
+      #   The number of records that were actually saved into the data-store
+      #
+      # @api semipublic
+      def create(resources)
+        raise NotImplementedError, "#{self.class}#create not implemented"
+      end
+
+      # Reads one or many resources from a datastore
+      #
+      # @example
+      #   adapter.read(query)  # => [ { 'name' => 'Dan Kubb' } ]
+      #
+      # Adapters provide specific implementation of this method
+      #
+      # @param [Query] query
+      #   the query to match resources in the datastore
+      #
+      # @return [Enumerable<Hash>]
+      #   an array of hashes to become resources
+      #
+      # @api semipublic
+      def read(query)
+        with_connection do |connection|
+          
+        end
+      end
+
+      # Updates one or many existing resources
+      #
+      # @example
+      #   adapter.update(attributes, collection)  # => 1
+      #
+      # Adapters provide specific implementation of this method
+      #
+      # @param [Hash(Property => Object)] attributes
+      #   hash of attribute values to set, keyed by Property
+      # @param [Collection] collection
+      #   collection of records to be updated
+      #
+      # @return [Integer]
+      #   the number of records updated
+      #
+      # @api semipublic
+      def update(attributes, collection)
+        raise NotImplementedError, "#{self.class}#update not implemented"
+      end
+
+      # Deletes one or many existing resources
+      #
+      # @example
+      #   adapter.delete(collection)  # => 1
+      #
+      # Adapters provide specific implementation of this method
+      #
+      # @param [Collection] collection
+      #   collection of records to be deleted
+      #
+      # @return [Integer]
+      #   the number of records deleted
+      #
+      # @api semipublic
+      def delete(collection)
+        raise NotImplementedError, "#{self.class}#delete not implemented"
+      end
+      
+      # Returns the name of the CouchDB database.
+      #
+      # @raise [RuntimeError] if the CouchDB database name is invalid.
+      def db_name
+        result = options[:path].scan(/^\/?([-_+%()$a-z0-9]+?)\/?$/).flatten[0]
+        if result != nil
+          return Addressable::URI.unencode_component(result)
+        else
+          raise StandardError, "Invalid database path: '#{options[:path]}'"
+        end
+      end
+
+      # Returns the name of the CouchDB database after being escaped.
+      def escaped_db_name
+        return Addressable::URI.encode_component(
+          self.db_name, Addressable::URI::CharacterClasses::UNRESERVED)
+      end
+
+            
+      private
+      
+      def initialize(repo_name, options = {})
+        super
+        
+        # When giving a repository URI rather than a hash, the database name
+        # is :path, with a leading slash.
+        if options[:path] && options[:database].nil?
+          options[:database] = db_name
+        end
+        
+        @resource_naming_convention = NamingConventions::Resource::Underscored
+        @uri = Addressable::URI.new(options.only(:scheme, :host, :path, :port))
+      end
+      
+      
+      # Returns the CouchRest::Database instance for this process.
+      #
+      # @return [CouchRest::Database]
+      #
+      # @raise [ConnectionError]
+      #   If the database requires you to authenticate, and the given username
+      #   or password was not correct, a ConnectionError exception will be
+      #   raised.
+      #
+      # @api semipublic
+      def database
+        unless defined?(@database)
+          @database = connection.database!(@options[:database])
+        end
+        @database
+      rescue Errno::ECONNREFUSED
+        DataMapper.logger.error("Could Not Connect to Database!")
+        raise(ConnectionError, "The adapter could not connect to Couchdb running at '#{@uri}'")
+      end
+      
+      def with_connection
+        begin
+          yield connection
+        rescue => e
+          DataMapper.logger.error(exception.to_s)
+          raise e
+        end
+      end
+      
+      # @see #connection
+      def connection
+        @connection ||= open_connection
+      end
+      
+      # Returns CouchRest::Server instance
+      # @return [CouchRest::Server]
+      # @todo reset! connection and allow #uuid_batch_count to change
+      #       also....do I need to use #chainable for this?
+      # @api semipublic
+      def open_connection
+        CouchRest::Server.new(@uri)
+      end
+    end # CouchDBAdapter
+
+    # Required naming scheme.
+    CouchdbAdapter = CouchDBAdapter
+    const_added(:CouchdbAdapter)
+  end
+end

data/lib/couchdb_adapter/attachments.rb

@@ -0,0 +1,121 @@
+require 'base64'
+require 'net/http'
+require 'rubygems'
+
+gem 'mime-types', '~>1.15'
+require 'mime/types'
+
+module DataMapper
+  module CouchResource
+    module Attachments
+
+      def self.included(mod)
+        mod.class_eval do
+
+          def add_attachment(file, options = {})
+            assert_attachments_property
+
+            filename = File.basename(file.path)
+
+            content_type = options[:content_type] || begin
+              mime_types = MIME::Types.of(filename)
+              mime_types.empty? ? 'application/octet-stream' : mime_types.first.content_type
+            end
+
+            name = options[:name] || filename
+            data = file.read
+
+            if new_record? || !model.properties.has_property?(:rev)
+              self.attachments ||= {}
+              self.attachments[name] = {
+                'content_type' => content_type,
+                'data'         => Base64.encode64(data).chomp,
+              }
+            else
+              adapter = repository.adapter
+              http = Net::HTTP.new(adapter.uri.host, adapter.uri.port)
+              uri = Addressable::URI.encode_component("#{attachment_path(name)}?rev=#{self.rev}")
+              headers = {
+                'Content-Length' => data.size.to_s,
+                'Content-Type'   => content_type,
+              }
+              http.put(uri, data, headers)
+              self.reload
+            end
+
+          end
+
+          def delete_attachment(name)
+            assert_attachments_property
+
+            attachment = self.attachments[name] if self.attachments
+
+            unless attachment
+              return false
+            end
+
+            response = unless new_record?
+              adapter = repository.adapter
+              http = Net::HTTP.new(adapter.uri.host, adapter.uri.port)
+              uri = Addressable::URI.encode_component("#{attachment_path(name)}?rev=#{self.rev}")
+              http.delete(uri, 'Content-Type' => attachment['content_type'])
+            end
+
+            if response && !response.kind_of?(Net::HTTPSuccess)
+              false
+            else
+              self.attachments.delete(name)
+              self.attachments = nil if self.attachments.empty?
+              true
+            end
+          end
+
+          # TODO: cache data on model? (don't want to make resource dirty though...)
+          def get_attachment(name)
+            assert_attachments_property
+
+            attachment = self.attachments[name] if self.attachments
+
+            unless self.id && attachment
+              nil
+            else
+              adapter = repository.adapter
+              http = Net::HTTP.new(adapter.uri.host, adapter.uri.port)
+              uri = Addressable::URI.encode_component(attachment_path(name))
+              response, data = http.get(uri, 'Content-Type' => attachment['content_type'])
+
+              unless response.kind_of?(Net::HTTPSuccess)
+                nil
+              else
+                data
+              end
+            end
+
+          end
+
+          private
+
+          def attachment_path(name)
+            if new_record?
+              nil
+            else
+              "/#{repository.adapter.escaped_db_name}/#{self.id}/#{name}"
+            end
+          end
+
+          def assert_attachments_property
+            property = model.properties[:attachments]
+
+            unless property &&
+              property.type == DataMapper::Types::JsonObject &&
+              property.field == '_attachments'
+              raise ArgumentError, "Attachments require   property :attachments, JsonObject, :field => '_attachments'"
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/couchdb_adapter/collection.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Couch 
+    class Collection < Collection
+      attr_accessor :total_rows, :offset
+    end
+  end
+end