therealadam-couchrest-rails 0.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) Henry Poydar
+
+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,136 @@
+# CouchRest-Rails
+
+A Rails plugin for connecting to and working with a [CouchDB](http://couchdb.apache.org) document-oriented database via the [CouchRest](http://github.com/jchris/couchrest) RESTful CouchDB client.
+
+Specifically, this plugin provides the following utilities:
+
+* Initializer for use with a couchdb.yml configuration file
+* CouchDB-specific rake tasks (database creation, deletion, fixture loading, views synchronization)
+* CouchDB-specific fixtures
+* Setup and teardown helpers for spec'ing and testing
+* A paper-thin wrapper around CouchRest::ExtendedDocument
+
+This plugin currently assumes your application only uses one CouchDB database.  It does not interfere with the traditional relational database backend, so you can use that as a datastore alongside CouchDB if you want.  (In fact, you'll have to unwire the requirement for a relational database if you don't want to use one.)
+
+## Requirements
+
+* [CouchRest gem](http://github.com/jchris/couchrest)
+* [RSpec](http://github.com/dchelimsky/rspec) BDD framework (optional - for running plugin specs)
+* [RSpec-Rails](http://github.com/dchelimsky/rspec-rails) library (optional - for running plugin specs)
+
+
+## Installation
+
+Install with the native Rails plugin installation script:
+
+    script/plugin install git://github.com/hpoydar/couchrest_rails.git
+
+Or simply add to vendor/plugins and generate the files you need:
+
+    script/generate couch_rest_rails relax
+    
+The plugin creates two folder:
+
+* `db/couch/` - for storing CouchDB database information map and reduce functions (views) and lucene indexing (lucence
+* `test/fixtures/couch` - for storing and loading CouchDB fixtures (yaml)
+
+These paths can be customized in an initializer or environment configuration file:
+
+    CouchRestRails.fixtures_path  = 'custom/path/to/your/fixtures/from/app/root'
+    CouchRestRails.views_path     = 'custom/path/to/your/views/from/app/root'
+    
+## Usage    
+
+### Rake tasks
+
+Use the rake tasks to create, delete, reset, push views and load fixtures:
+
+    rake -T | grep couchdb
+    
+### Tests and specs
+    
+For testing or spec'ing, use these helpers to setup and teardown a test database with fixtures:
+
+    CouchRestRails::Tests.setup
+    CouchRestRails::Tests.teardown
+    
+There are also some simple matchers you can can use to spec validations.  See `spec/lib/matchers`.
+
+### CouchRestRails document model
+
+For models, inherit from CouchRestRails::Document, which hooks up CouchRest::ExtendedDocument to your CouchDB backend   and includes the [Validatable](http://validatable.rubyforge.org/) module:
+
+    class YourCouchDocument < CouchRestRails::Document
+      use_database :database_name
+
+      property  :email
+      property  :question
+      property  :answer
+      property  :rating
+
+      timestamps!
+
+      view_by :email
+      
+      validates_presence_of :question
+      validates_numericality_of :rating
+      
+      ...
+      
+    end
+
+See the CouchRest documentation and specs for more information about CouchRest::ExtendedDocument. (The views defined here are in addition to the ones you can manually set up and push via rake in db/couch/views.)
+
+### CouchDB views
+    
+Custom views--outside of the ones defined in your CouchRestRails::Document models--that you want to push up to the CouchDB database/server instance should be in the following format:
+
+    db/couch/<database_name>/views
+                               |-- <design_document_name>
+                                   |-- <view_name>
+                                       |-- map.js
+                                       `-- reduce.js
+                            /lucene
+                               |-- <design_document_name>
+                                     |-- <lucene_search>
+ 
+Push up your views via rake (`rake couchdb:views:push`) or within your code or console (`CouchRestRails::Views.push`).
+
+Push up your lucene doc via rake (`rake couchdb:lucence:push`) or within your code or console (`CouchRestRails::Lucene.push`).
+
+## Further development and testing
+
+To run the test suite, you'll need rspec installed with rspec-rails library enabled for the host application. You can run the tests in the following way:
+
+    <rails_root>$ rake spec:plugins
+    <plugin_root>$ rake spec
+    <plugin_root>$ autospec
+    
+(The latter requires the ZenTest gem)
+
+# Rails integration unit testing 
+
+Create fixture file by via rake (`rake couchdb:fixture:dump[<database_name>]`) or within your code or console (`CouchRestRails::Fixtures.dump[<database_name>]`).
+
+Add fixtures to rails test:
+
+class RailsTest < Test::Unit::TestCase
+    couchdb_fixtures :<database_name>
+
+    ...
+
+end
+
+## TODO
+
+* Roll up CouchRest::ExtendedDocument, since it might be deprecated from CouchRest (see CouchRest raw branch)
+* A persistent connection object? Keep-alive?
+* Hook into Rails logger to display times for CouchDB operations
+* Mechanism for better view testing?
+* Restful model/controller/test/spec generator
+* Gemify
+* Add more parseable options to couchdb.yml
+
+## License
+
+Copyright (c) Henry Poydar, released under the MIT license

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'couchrest-rails'
+    gemspec.summary = 'Make working with CouchDB and Rails even better.'
+    gemspec.description = 'Rails plugin for connecting to and working with CouchDB via CouchRest'
+    gemspec.homepage = 'http://github.com/therealadam/couchrest-rails'
+    gemspec.authors = ['Henry Poydar']
+  end
+rescue LoadError
+  puts "Jeweler not available. Can't build RubyGems."
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/generators/couch_rest_rails/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates the files needed for your Rails application to connect to and work with a CouchDB database over CouchRest.
+
+Example:
+    ./script/generate couchrest_rails relax
+
+    This will create:
+        config/initializers/couchdb.rb

data/generators/couch_rest_rails/couch_rest_rails_generator.rb

@@ -0,0 +1,11 @@
+class CouchRestRailsGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+
+      m.directory "db/couch"
+      m.directory "test/fixtures/couch"
+      m.template "couchdb.yml", "config/couchdb.yml"
+      m.template "couchdb_initializer.rb", "config/initializers/couchdb.rb"
+    end
+  end
+end

data/generators/couch_rest_rails/templates/couchdb.yml

@@ -0,0 +1,13 @@
+base: &base
+ database_prefix: 
+ database_suffix: _<%=RAILS_ENV%>
+
+development:
+  host: localhost
+  port: 5984
+  <<: *base
+  
+test:
+  host: localhost
+  port: 5984
+  <<: *base

data/generators/couch_rest_rails/templates/couchdb_initializer.rb

@@ -0,0 +1,36 @@
+begin
+
+  env = ENV['RAILS_ENV'] || 'development'
+
+  couchdb_config = YAML::load(ERB.new(IO.read(RAILS_ROOT + "/config/couchdb.yml")).result)[env]
+
+  host      = couchdb_config["host"]      || 'localhost'
+  port      = couchdb_config["port"]      || '5984'
+  database  = couchdb_config["database"]
+  username  = couchdb_config["username"]
+  password  = couchdb_config["password"]
+  ssl       = couchdb_config["ssl"]       || false
+  db_prefix = couchdb_config["database_prefix"] || ""
+  db_suffix = couchdb_config["database_suffix"] || ""
+  host     = "localhost"  if host == nil
+  port     = "5984"       if port == nil
+  ssl      = false        if ssl == nil
+
+  protocol = ssl ? 'https' : 'http'
+  authorized_host = (username.blank? && password.blank?) ? host :
+    "#{CGI.escape(username)}:#{CGI.escape(password)}@#{host}"
+
+rescue
+
+  raise "There was a problem with your config/couchdb.yml file. Check and make sure it's present and the syntax is correct."
+
+else
+
+  COUCHDB_CONFIG = {
+    :host_path => "#{protocol}://#{authorized_host}:#{port}",
+    :db_prefix => "#{db_prefix}",
+    :db_suffix => "#{db_suffix}"
+  }
+
+  COUCHDB_SERVER = CouchRest.new COUCHDB_CONFIG[:host_path]
+end

data/init.rb

@@ -0,0 +1,7 @@
+require 'couch_rest_rails'
+require 'validatable'
+require 'spec/rails/matchers/couch_document_validations'
+
+config.gem 'couchrest'
+config.gem 'validatable'
+config.gem 'json'

data/install.rb

@@ -0,0 +1,3 @@
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+Rails::Generator::Scripts::Generate.new.run(['couchrest_rails', 'relax'], :destination => RAILS_ROOT)

data/lib/autotest/discover.rb

@@ -0,0 +1,5 @@
+$:.push(File.join(File.dirname(__FILE__), %w[.. .. rspec]))  
+
+Autotest.add_discovery do  
+  "rspec" 
+end

data/lib/couch_rest_rails.rb

@@ -0,0 +1,12 @@
+module CouchRestRails
+
+  mattr_accessor :test_environment
+  self.test_environment = 'test'
+
+  mattr_accessor :setup_path
+  self.setup_path = 'db/couch'
+
+  mattr_accessor :fixture_path
+  self.fixture_path = 'test/fixtures/couch'
+
+end

data/lib/couch_rest_rails/database.rb

@@ -0,0 +1,64 @@
+module CouchRestRails
+  module Database
+
+    extend self
+
+    def create(database)
+      resp = []
+      return  "Database '#{database}' doesn't exists" unless
+        (database == "*" || File.exist?(File.join(RAILS_ROOT,
+                                                  CouchRestRails.setup_path,
+                                                  database)))
+
+      # get list of available_databases in couch...
+      existing_databases = COUCHDB_SERVER.databases
+      # get all the model files
+      Dir[File.join(RAILS_ROOT, CouchRestRails.setup_path,database)].each do |db|
+        # check for a directory...
+        if File::directory?( db )
+          database_name =COUCHDB_CONFIG[:db_prefix] +  File.basename(db) +
+            COUCHDB_CONFIG[:db_suffix]
+          if existing_databases.include?(database_name)
+            resp << "The CouchDB database '#{database_name}' already exists"
+          else
+            # create the database
+            COUCHDB_SERVER.create_db(database_name)
+            resp << "Created the CouchDB database '#{database_name}'"
+            # create views on database
+            resp << CouchRestRails::Views.push(File.basename(db),"*")
+            # create lucene-searches
+            resp << CouchRestRails::Lucene.push(File.basename(db),"*")
+          end
+        end
+      end
+      resp << "create complete"
+      resp.join("\n")
+    end
+
+    def delete(database)
+      resp = []
+      return  "Database '#{database}' doesn't exists" unless
+        (database == "*" || File.exist?(File.join(RAILS_ROOT,
+                                                  CouchRestRails.setup_path,
+                                                  database)))
+      # get list of available_databases in couch...
+      existing_databases = COUCHDB_SERVER.databases
+      # get all the model files
+      Dir[File.join(RAILS_ROOT, CouchRestRails.setup_path,database)].each do |db|
+        # check for a directory...
+        if File::directory?( db )
+          database_name =COUCHDB_CONFIG[:db_prefix] +  File.basename(db) +
+            COUCHDB_CONFIG[:db_suffix]
+          if existing_databases.include?(database_name)
+            CouchRest.delete "#{COUCHDB_CONFIG[:host_path]}/#{database_name}"
+            resp << "Dropped CouchDB database '#{database_name}'"
+          else
+            resp << "The CouchDB database '#{database_name}' does not exist"
+          end
+        end
+      end
+      resp << "delete complete"
+      resp.join("\n")
+    end
+  end
+end

data/lib/couch_rest_rails/document.rb

@@ -0,0 +1,12 @@
+module CouchRestRails
+  class Document < CouchRest::ExtendedDocument
+
+    include Validatable
+
+     def self.use_database(db)
+       db = COUCHDB_CONFIG[:db_prefix] + db.to_s + COUCHDB_CONFIG[:db_suffix]
+       # add prefix and suffix to db
+       self.database = COUCHDB_SERVER.database(db)
+     end
+  end
+end

data/lib/couch_rest_rails/fixtures.rb

@@ -0,0 +1,54 @@
+module CouchRestRails
+  module Fixtures
+
+    extend self
+    
+    def load(database)
+      fixture_files = []
+      return  "Database '#{database}' doesn't exists" unless (database == "*" ||
+                                                              File.exist?(File.join(RAILS_ROOT, CouchRestRails.setup_path, database)))
+      Dir[File.join(RAILS_ROOT, CouchRestRails.setup_path, database)].each do |db|
+        db_name =COUCHDB_CONFIG[:db_prefix] +  File.basename( db) +
+          COUCHDB_CONFIG[:db_suffix]
+        res = CouchRest.get("#{COUCHDB_CONFIG[:host_path]}/#{db_name}") rescue nil
+        if res
+          db_con = CouchRest.database("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+          Dir.glob(File.join(RAILS_ROOT, CouchRestRails.fixture_path, "#{database}.yml")).each do |file|
+            db_con.bulk_save(YAML::load(ERB.new(IO.read(file)).result).map {|f| f[1]})
+            fixture_files << File.basename(file)
+          end
+        end
+        if fixture_files.empty?
+          return "No fixtures found in #{CouchRestRails.fixture_path}"
+        else
+          return "Loaded the following fixture files into '#{db}': #{fixture_files.join(', ')}"
+        end
+      end
+    end
+
+    def dump(database)
+      return  "Database '#{database}' doesn't exists" unless (database == "*" ||
+                                                              File.exist?(File.join(RAILS_ROOT, CouchRestRails.setup_path, database)))
+      Dir[File.join(RAILS_ROOT, CouchRestRails.setup_path, database)].each do |db|
+        db_name =COUCHDB_CONFIG[:db_prefix] +  File.basename( db) +
+          COUCHDB_CONFIG[:db_suffix]
+        res = CouchRest.get("#{COUCHDB_CONFIG[:host_path]}/#{db_name}") rescue nil
+        if res
+          File.open(File.join(RAILS_ROOT, CouchRestRails.fixture_path, "#{database}.yml"), 'w' ) do |file|
+            yaml_hash = {}
+            db_con = CouchRest.database("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+            docs = db_con.documents(:include_docs =>true )
+            docs["rows"].each { |data|
+              doc = data["doc"]
+              unless  (doc['_id'] =~ /^_design*/) == 0
+                doc.delete('_rev')
+                yaml_hash[doc['_id']] = doc
+              end
+            }
+            file.write yaml_hash.to_yaml
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_rest_rails/lucene.rb

@@ -0,0 +1,61 @@
+require 'json'
+
+module CouchRestRails
+  module Lucene
+    extend self
+
+    # Push index/search views to CouchDB
+    def push(database, design_doc)
+      result = []
+      result << "database = #{database} :: design_doc = #{design_doc}"
+      db_dir = File.join(RAILS_ROOT, CouchRestRails.setup_path, database)
+      return "Database '#{database}' does not exist" unless (database == "*" || File.exist?(db_dir))
+
+      Dir[db_dir].each do |db|
+        return "Lucene directory '#{db}/lucene' does not exist." unless File.exist?("#{db}/lucene")
+
+        # CouchDB checks
+        db_name = COUCHDB_CONFIG[:db_prefix] + File.basename(db) + COUCHDB_CONFIG[:db_suffix]
+        begin
+          CouchRest.get("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+        rescue => err
+          return "CouchDB database '#{db_name}' does not exist. Create it first. (#{err})"
+        end
+
+        # Update CouchDB designs
+        db_con = CouchRest.database("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+        Dir.glob(File.join(db, 'lucene', design_doc)).each do |doc|
+          design_doc_name = File.basename(doc)
+
+          # Load lucene definition views from FS
+          index_views = assemble_lucene(doc)
+          couchdb_design = db_con.get("_design/#{design_doc_name}") rescue nil
+
+          # Update CouchDB's design with fulltext definition files
+          if index_views.blank?
+            result << "No search was found in #{doc}/#{design_doc_name}"
+          else
+            # Create the design doc, and/or update fulltext property
+            couchdb_design = { '_id' => "_design/#{design_doc_name}" } if couchdb_design.nil?
+            couchdb_design['fulltext'] = index_views
+
+            db_con.save_doc(couchdb_design)
+            result << "Added lucene fulltext views to #{design_doc_name}: #{index_views.keys.join(', ')}"
+          end
+
+        end
+      end
+      result.join("\n")
+    end
+
+    # Assemble views from file-system path lucene_doc_path
+    def assemble_lucene(lucene_doc_path)
+      search = {}
+      Dir.glob(File.join(lucene_doc_path, '*')).each do |search_file|
+        search_name = File.basename(search_file).sub(/\.js$/, '')
+        search[search_name] = JSON.parse(IO.read(search_file).gsub(/\n/, ''))
+      end
+      search
+    end
+  end
+end

data/lib/couch_rest_rails/tests.rb

@@ -0,0 +1,53 @@
+module CouchRestRails
+  module Tests
+
+    extend self
+    mattr_accessor :fixtures_loaded
+    self.fixtures_loaded = Set.new
+
+    def setup(database="*")
+      ENV['RAILS_ENV'] = CouchRestRails.test_environment
+      unless fixtures_loaded.include?(database)
+        CouchRestRails::Database.delete(database)
+        CouchRestRails::Database.create(database)
+        CouchRestRails::Fixtures.load(database)
+        fixtures_loaded << database
+      end
+    end
+
+    def reset_fixtures
+      CouchRestRails::Database.delete("*") unless fixtures_loaded.empty?
+      fixtures_loaded.clear
+    end
+
+    def teardown(database="*")
+      ENV['RAILS_ENV'] = CouchRestRails.test_environment
+      CouchRestRails::Database.delete(database)
+      CouchRestRails::Database.create(database)
+      fixtures_loaded.delete(database)
+    end
+  end
+end
+module Test
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      setup :setup_couchdb_fixtures
+      teardown :teardown_couchdb_fixtures
+
+      superclass_delegating_accessor :database
+      self.database = nil
+
+      class << self
+        def couchdb_fixtures(*databases)
+          self.database = databases.map { |d| d.to_s }
+        end
+      end
+      def setup_couchdb_fixtures
+        CouchRestRails::Tests.setup(self.database) unless self.database.nil?
+      end
+      def teardown_couchdb_fixtures
+        CouchRestRails::Tests.teardown(self.database) unless self.database.nil?
+      end
+    end
+  end
+end

data/lib/couch_rest_rails/views.rb

@@ -0,0 +1,72 @@
+module CouchRestRails
+  module Views
+    extend self
+
+    # Push views to couchdb
+    def push(database, design_doc)
+      result = []
+      result << "database = #{database} :: design_doc = #{design_doc}"
+      db_dir = File.join(RAILS_ROOT, CouchRestRails.setup_path, database)
+      return "Database directory '#{database}' does not exist" unless (database == "*" || File.exist?(db_dir))
+
+      Dir[db_dir].each do |db|
+        return "Views directory '#{db}/views' does not exist"  unless File.exist?("#{db}/views")
+
+        # CouchDB checks
+        db_name = COUCHDB_CONFIG[:db_prefix] + File.basename(db) + COUCHDB_CONFIG[:db_suffix]
+        begin
+          CouchRest.get("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+        rescue => err
+          return "CouchDB database '#{db_name}' does not exist. Create it first. (#{err})"
+        end
+
+        db_con = CouchRest.database("#{COUCHDB_CONFIG[:host_path]}/#{db_name}")
+        Dir.glob(File.join(db, "views", design_doc)).each do |doc|
+          design_doc_name = File.basename(doc)
+
+          # Load views from filesystem & CouchDB
+          views = assemble_views(doc)
+          couchdb_design = db_con.get("_design/#{design_doc_name}") rescue nil
+
+          # Update CouchDB's freshly-fetched views, but don't destroy
+          # any view not referenced on the FS. Not sure about that part:
+          # should we synchronize aggressively?
+          views = couchdb_design['views'].merge(views) unless couchdb_design.nil?
+
+          if views.empty?
+            result << "No updatable views in #{doc}/#{File.basename(doc)}"
+          else
+
+            # Create or update the design, then set its views
+            if couchdb_design.nil?
+              couchdb_design = { '_id'      => "_design/#{design_doc_name}",
+                                 'language' => 'javascript' }
+            end
+            couchdb_design['views'] = views
+
+            db_con.save_doc(couchdb_design)
+            result << "Added views to #{design_doc_name}: #{views.keys.join(', ')}"
+          end
+        end
+        result << "No views were found in '#{File.join(db, "views", design_doc)}'" if result.empty?
+      end
+      result.join("\n")
+    end
+
+    # Assemble views from file-system path design_doc_path
+    def assemble_views(design_doc_path)
+      views = {}
+
+      Dir.glob(File.join(design_doc_path, '*')).each do |view_folder|
+        view = {}
+        map_file    = File.join(view_folder, 'map.js')
+        reduce_file = File.join(view_folder, 'reduce.js')
+
+        view[:map]    = IO.read(map_file)    if File.exist?(map_file)
+        view[:reduce] = IO.read(reduce_file) if File.exist?(reduce_file) && File.size(reduce_file) > 0
+        views[File.basename(view_folder)] = view if view[:map]
+      end
+      views
+    end
+  end
+end

data/lib/couch_rest_tasks.rb

@@ -0,0 +1,54 @@
+namespace :couchdb do
+
+  desc "Create the CouchDB database defined in config/couchdb.yml for the current environment"
+  task :create, :database, :needs => :environment do |t, args|
+      args.with_defaults(:database => "*")
+      puts CouchRestRails::Database.create(args.database)
+  end
+
+  desc "Deletes the CouchDB database for the current RAILS_ENV"
+  task :delete, :database, :needs => :environment do |t, args|
+      args.with_defaults(:database => "*")
+      puts CouchRestRails::Database.delete(args.database)
+  end
+
+  desc "Deletes and recreates the CouchDB database for the current RAILS_ENV"
+  task :reset => [:delete, :create]
+
+  namespace :test do
+    desc "Empty the test CouchDB database"
+    task :reset do
+      `rake RAILS_ENV=test couchdb:delete`
+      `rake RAILS_ENV=test couchdb:create`
+    end
+  end
+
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's CouchDB database"
+    task :load, :database, :needs  => :environment do |t, args|
+      args.with_defaults(:database => "*")
+      puts CouchRestRails::Fixtures.load(args.database)
+    end
+    task :dump, :database, :needs => :environment do |t, args|
+      args.with_defaults(:database => "*")
+      puts CouchRestRails::Fixtures.dump(args.database)
+    end
+  end
+
+  namespace :views do
+    desc "Push views into the current environment's CouchDB database"
+    task :push, :database, :design_doc, :needs => :environment do |t, args|
+      args.with_defaults(:database => "*", :design_doc => "*")
+      puts CouchRestRails::Views.push(args.database, args.design_doc)
+    end
+  end
+
+  namespace :lucene do
+    desc "Push views into the current environment's CouchDB database"
+    task :push, :database, :design_doc, :needs => :environment do |t, args|
+      args.with_defaults(:database => "*", :design_doc => "*")
+      puts CouchRestRails::Lucene.push(args.database, args.design_doc)
+    end
+  end
+
+end

data/lib/spec/rails/matchers/couch_document_validations.rb

@@ -0,0 +1,44 @@
+module Spec
+  module Rails
+    module Matchers
+      
+      def validate_couchdb_document_format_of(attribute, options)
+        return simple_matcher("document model to validate format of :#{attribute} with #{options[:with]}") do |model|
+          model.send("#{attribute}=", nil)
+          !model.valid? && model.errors.on(attribute)
+        end
+      end
+      
+      def validate_couchdb_document_length_of(attribute, options)
+        return simple_matcher("document model to validate length of :#{attribute} within
+          #{options[:maximum] || 0} to #{options[:minimum] || 'infinity'}") do |model|
+          if options[:within]
+             model.send("#{attribute}=", 'x' * (options[:within].last + 1))
+          else
+            if options[:maximum]
+              model.send("#{attribute}=", 'x' * (options[:maximum] + 1))
+            else
+              model.send("#{attribute}=", 'x' * (options[:minimum] - 1))
+            end
+          end
+          !model.valid? && model.errors.on(attribute)
+        end
+      end
+      
+      def validate_couchdb_document_presence_of(attribute)
+        return simple_matcher("document model to validate presence of :#{attribute}") do |model|
+          model.send("#{attribute}=", nil)
+          !model.valid? && model.errors.on(attribute)
+        end
+      end
+      
+      def validate_couchdb_document_numericality_of(attribute)
+        return simple_matcher("document model to validate numericality of :#{attribute}") do |model|
+          model.send("#{attribute}=", 'x')
+          !model.valid? && model.errors.on(attribute)
+        end
+      end
+      
+    end
+  end
+end

data/spec/lib/couch_rest_rails/database_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRestRails::Views do
+
+  before :each do
+    CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+  end
+  
+  after :all do
+    CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+  end
+
+  describe '#create' do
+  
+    it 'should create a CouchDB database for the current environment' do
+      CouchRestRails::Database.create
+      res = CouchRest.get(COUCHDB_CONFIG[:full_path])
+      res['db_name'].should == COUCHDB_CONFIG[:database]
+    end
+
+    it 'should do nothing and display a message if the database already exists' do
+      CouchRest.database!("#{COUCHDB_CONFIG[:full_path]}")
+      res = CouchRestRails::Database.create
+      res.should =~ /already exists/i
+    end
+
+  end
+  
+  describe "#delete" do
+    
+    it 'should delete the CouchDB database for the current environment' do
+      CouchRest.database!("#{COUCHDB_CONFIG[:full_path]}")
+      CouchRestRails::Database.delete
+      lambda {CouchRest.get(COUCHDB_CONFIG[:full_path])}.should raise_error('Resource not found')
+    end
+
+    it 'should do nothing and display a message if the database does not exist' do
+      res = CouchRestRails::Database.delete
+      res.should =~ /does not exist/i
+    end
+    
+  end
+
+end

data/spec/lib/couch_rest_rails/document_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRestRails::Document do
+  
+  class CouchRestRailsTestDocument < CouchRestRails::Document 
+    
+  end
+  
+  before :each do
+    @doc = CouchRestRailsTestDocument.new
+  end
+  
+  it "should inherit from CouchRest::ExtendedDocument" do
+    CouchRestRails::Document.ancestors.include?(CouchRest::ExtendedDocument).should be_true
+  end
+  
+  it "should use the COUCHDB_SERVER constant to define its CouchDB connection" do
+    @doc.database.name.should == COUCHDB_CONFIG[:database]
+  end
+
+  
+end

data/spec/lib/couch_rest_rails/fixtures_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRestRails::Fixtures do
+  
+  describe '#blurbs' do
+    
+    it 'should produce an array of text blurbs for testing purposes' do
+      CouchRestRails::Fixtures.blurbs.is_a?(Array).should be_true
+    end
+  
+    it 'should produce a random text blurb' do
+      CouchRestRails::Fixtures.random_blurb.is_a?(String).should be_true
+    end
+  
+  end
+
+  describe '#load' do
+  
+    before :each do
+      CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+    end
+    
+    after :all do
+      CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+    end
+  
+    it "should exit if the database doesn't exist" do
+      res = CouchRestRails::Fixtures.load
+      res.should =~ /does not exist/i
+    end
+
+    it "should load up the yaml files in CouchRestRails.fixtures_path as documents" do
+      db = CouchRest.database!(COUCHDB_CONFIG[:full_path])
+      CouchRestRails.fixtures_path = 'vendor/plugins/couchrest-rails/spec/mock/fixtures'
+      CouchRestRails::Fixtures.load
+      db.documents['rows'].size.should == 10
+    end
+  
+  end
+
+end

data/spec/lib/couch_rest_rails/tests_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRestRails::Tests do
+  
+  before :each do
+    CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+    CouchRestRails.fixtures_path = 'vendor/plugins/couchrest-rails/spec/mock/fixtures'
+    CouchRestRails.views_path = 'vendor/plugins/couchrest-rails/spec/mock/views'
+  end
+  
+  after :all do
+    CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+  end
+  
+  describe '#setup' do
+    
+    it 'should delete, add and load fixtures for the test database' do
+      
+      # Create a dirty db first...
+      CouchRestRails::Database.create
+      db = CouchRest.database(COUCHDB_CONFIG[:full_path])
+      CouchRestRails::Fixtures.load
+      db.documents['rows'].size.should == 10
+      
+      CouchRestRails::Tests.setup
+      db.documents['rows'].size.should == 12 # Includes design docs
+      db.view('foos/all')['rows'].size.should == 5
+    
+    end
+    
+  end
+  
+  describe '#teardown' do
+    
+    it 'should delete the test database' do
+      CouchRestRails::Tests.setup
+      db = CouchRest.database(COUCHDB_CONFIG[:full_path])
+      db.documents['rows'].size.should == 12 # Includes design docs
+      CouchRestRails::Tests.teardown
+      lambda {CouchRest.get(COUCHDB_CONFIG[:full_path])}.should raise_error('Resource not found')
+    end
+    
+  end
+    
+end

data/spec/lib/couch_rest_rails/views_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe CouchRestRails::Views do
+  
+  before :each do
+    CouchRestRails.views_path = 'vendor/plugins/couchrest-rails/spec/mock/views'
+    CouchRestRails.fixtures_path = 'vendor/plugins/couchrest-rails/spec/mock/fixtures'
+    
+  end
+  
+  after :all do
+    CouchRestRails::Tests.teardown
+  end
+  
+  describe '#push' do
+  
+    it "should push the views in CouchRestRails.views_path to a design document for the database" do
+      CouchRestRails::Tests.setup # Pushes views
+      db = CouchRest.database(COUCHDB_CONFIG[:full_path])
+      db.view('foos/all')['rows'].size.should == 5
+    end
+  
+  end
+  
+end

data/spec/lib/couch_rest_rails_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'rails_generator'
+require 'rails_generator/scripts/generate'
+
+describe 'CouchRestRails' do
+  
+  after :all do
+    CouchRest.delete(COUCHDB_CONFIG[:full_path]) rescue nil
+  end
+  
+  describe 'plugin installation' do
+    
+    before :all do
+      @fake_rails_root = File.join(File.dirname(__FILE__), 'rails_root')
+      FileUtils.mkdir_p(@fake_rails_root)
+      FileUtils.mkdir_p("#{@fake_rails_root}/config/initializers")
+    end
+    
+    after :all do
+      FileUtils.rm_rf(@fake_rails_root)
+    end
+    
+    it "should generate the necessary files in the host application" do
+      Rails::Generator::Scripts::Generate.new.run(
+        ['couchrest_rails', 'relax'], :destination => @fake_rails_root)
+      Dir.glob(File.join(@fake_rails_root, "**", "*.*")).map {|f| File.basename(f)}.should == 
+        ['couchdb.yml', 'couchdb.rb']
+    end
+    
+  end
+  
+end

data/spec/matchers/couch_document_validations_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spec::Rails::Matchers do
+  
+  describe 'validations' do
+    
+    before :all do
+      class CouchFoo < CouchRestRails::Document  
+        
+        property  :something_present
+        property  :something_long
+        property  :something_formatted
+        property  :something_numeric
+        
+        validates_presence_of     :something_present
+        validates_length_of       :something_long, :minimum => 10, :maximum => 50
+        validates_format_of       :something_formatted, :with => /[A-Z]{3}-[0-9]{3}/
+        validates_numericality_of :something_numeric
+
+      end
+      @couch_foo = CouchFoo.new
+    end
+    
+    # Use lengthy matcher names so as not to interfere with 
+    # rspec-on-rails-matchers plugin if present
+    
+    it "should have a matcher for validates_presence_of" do
+      @couch_foo.should validate_couchdb_document_presence_of(:something_present)
+    end
+    
+    it "should have a matcher for validates_numericality_of" do
+      @couch_foo.should validate_couchdb_document_numericality_of(:something_numeric)
+    end
+    
+    it "should have a matcher for validates_format_of" do
+      @couch_foo.should validate_couchdb_document_format_of(:something_formatted, :with => /[A-Z]{3}-[0-9]{3}/)
+    end
+    
+    it "should have a matcher for validates_length_of" do
+      @couch_foo.should validate_couchdb_document_length_of(:something_long, :minimum => 10, :maximum => 50)
+    end
+    
+  end
+  
+end

data/spec/mock/fixtures/bars.yml

@@ -0,0 +1,11 @@
+<% def blurb; CouchRestRails::Fixtures.random_blurb; end %>
+
+<% 5.times do |i| %>
+record_<%= i %>:
+  type: Bar
+  question: <%= blurb.split('.').first %>
+  answer: <%= blurb %>
+  rating: <%= rand(10) %>
+  created_at: <%= (Time.now - 3600*rand(10)).utc.strftime('%Y/%m/%d %H:%M:%S +0000') %>
+  updated_at: <%= Time.now.utc.strftime('%Y/%m/%d %H:%M:%S +0000') %>
+<% end %>

data/spec/mock/fixtures/foos.yml

@@ -0,0 +1,11 @@
+<% def blurb; CouchRestRails::Fixtures.random_blurb; end %>
+
+<% 5.times do |i| %>
+record_<%= i %>:
+  type: Foo
+  title: <%= blurb.split('.').first %>
+  body: <%= blurb %>
+  tags: <%= blurb.split(' ').sort_by {rand}[0..3].map {|e| e.downcase.gsub(/[^a-z]/, '').strip}.inspect %>
+  created_at: <%= (Time.now - 3600*rand(10)).utc.strftime('%Y/%m/%d %H:%M:%S +0000') %>
+  updated_at: <%= Time.now.utc.strftime('%Y/%m/%d %H:%M:%S +0000') %>
+<% end %>

data/spec/mock/views/bars/all/map.js

@@ -0,0 +1,9 @@
+function(doc) {
+  if(doc.type == 'Bar') {
+    emit(doc.question, {
+      answer : doc.answer,
+      rating : doc.rating,
+      created_at : doc.created_at
+    });
+  }
+};

data/spec/mock/views/foos/all/map.js

@@ -0,0 +1,9 @@
+function(doc) {
+  if(doc.type == 'Foo') {
+    emit(doc.created_at, {
+      title : doc.title,
+      body : doc.body,
+      created_at : doc.created_at
+    });
+  }
+};

data/spec/mock/views/foos/tags/map.js

@@ -0,0 +1,7 @@
+function(doc) {
+  if(doc.type == 'Foo' && doc.tags && doc.tags.length) {
+    for(var idx in doc.tags) {
+      emit(doc.tags[idx], 1);
+    }
+  }
+}

data/spec/mock/views/foos/tags/reduce.js

@@ -0,0 +1,3 @@
+function(key, values) {
+  return sum(values);
+}

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+begin
+  require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
+rescue LoadError
+  puts "You need to install rspec in your base application"
+  exit
+end

data/tasks/couch_rest_rails_tasks.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '../lib/couch_rest_tasks')

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: therealadam-couchrest-rails
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Henry Poydar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-22 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin for connecting to and working with CouchDB via CouchRest
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.md
+- Rakefile
+- VERSION
+- generators/couch_rest_rails/USAGE
+- generators/couch_rest_rails/couch_rest_rails_generator.rb
+- generators/couch_rest_rails/templates/couchdb.yml
+- generators/couch_rest_rails/templates/couchdb_initializer.rb
+- init.rb
+- install.rb
+- lib/autotest/discover.rb
+- lib/couch_rest_rails.rb
+- lib/couch_rest_rails/database.rb
+- lib/couch_rest_rails/document.rb
+- lib/couch_rest_rails/fixtures.rb
+- lib/couch_rest_rails/lucene.rb
+- lib/couch_rest_rails/tests.rb
+- lib/couch_rest_rails/views.rb
+- lib/couch_rest_tasks.rb
+- lib/spec/rails/matchers/couch_document_validations.rb
+- spec/lib/couch_rest_rails/database_spec.rb
+- spec/lib/couch_rest_rails/document_spec.rb
+- spec/lib/couch_rest_rails/fixtures_spec.rb
+- spec/lib/couch_rest_rails/tests_spec.rb
+- spec/lib/couch_rest_rails/views_spec.rb
+- spec/lib/couch_rest_rails_spec.rb
+- spec/matchers/couch_document_validations_spec.rb
+- spec/mock/fixtures/bars.yml
+- spec/mock/fixtures/foos.yml
+- spec/mock/views/bars/all/map.js
+- spec/mock/views/foos/all/map.js
+- spec/mock/views/foos/tags/map.js
+- spec/mock/views/foos/tags/reduce.js
+- spec/spec_helper.rb
+- tasks/couch_rest_rails_tasks.rake
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/therealadam/couchrest-rails
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Make working with CouchDB and Rails even better.
+test_files: 
+- spec/lib/couch_rest_rails/database_spec.rb
+- spec/lib/couch_rest_rails/document_spec.rb
+- spec/lib/couch_rest_rails/fixtures_spec.rb
+- spec/lib/couch_rest_rails/tests_spec.rb
+- spec/lib/couch_rest_rails/views_spec.rb
+- spec/lib/couch_rest_rails_spec.rb
+- spec/matchers/couch_document_validations_spec.rb
+- spec/spec_helper.rb