ShyCouch 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem "sourcify", "~> 0.5.0"
+  gem "ShyRubyJS"
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ShyRubyJS (0.0.1)
+      sourcify (~> 0)
+    file-tail (1.0.6)
+      spruz (~> 0.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.10)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.6)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    sourcify (0.5.0)
+      file-tail (>= 1.0.5)
+      ruby2ruby (>= 1.2.5)
+      ruby_parser (>= 2.0.5)
+      sexp_processor (>= 3.0.5)
+    spruz (0.2.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ShyRubyJS
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  sourcify (~> 0.5.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Cerales
+
+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,36 @@
+= ShyCouch
+
+ShyCouch is a Ruby library for CouchDB. It's a data persistence layer that uses native objects and a simple query language, designed primarily to replace ActiveRecord in micro-frameworks like Camping. A Python version is forthcoming.
+
+I'm mainly putting this up for feedback at the moment. It's a complete mess, I haven't figured out where 
+
+ShyCouch does not come with an elaborate query language. It'll automatically create an 'all' query for all your models (don't use it unless you have a really good excuse not to write a custom query, doing the filtering at the application layer is hell slow), but aside from that you have to write your own map and reduce functions.
+
+= Usage
+
+erghgrehg TODO
+
+= Map/Reduce
+
+ShyCouch uses the related ShyRubyJS library to parse Ruby blocks as JavaScript. This means you can do this:
+
+	map {
+	  def function(doc)
+	    if doc.kind == "post" and !doc.hidden
+	      emit(doc)
+	  end
+	}
+
+and you'll get this:
+
+	function ( doc ) { 
+	  if( doc.kind.==("post") && !doc.hidden ) {
+	    emit(doc)
+	  } 
+	}
+
+== Copyright
+
+Copyright (c) 2011 Cerales. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ShyCouch"
+  gem.homepage = "http://github.com/Cerales/ShyCouch"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby API for CouchDB, designed to work with the Camping micro-framework.}
+  gem.description = %Q{Ruby API for CouchDB, designed to work with the Camping micro-framework.}
+  gem.email = "danbryan@gmail.com"
+  gem.authors = ["Shy Inc.", "Daniel Bryan", "Cerales"]
+  gem.add_dependency "ShyRubyJS"
+  gem.add_dependency "sourcify", ">=0"
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ShyCouch #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/ShyCouch.gemspec

@@ -0,0 +1,75 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ShyCouch}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Shy Inc.}, %q{Daniel Bryan}, %q{Cerales}]
+  s.date = %q{2011-08-14}
+  s.description = %q{Ruby API for CouchDB, designed to work with the Camping micro-framework.}
+  s.email = %q{danbryan@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "ShyCouch.gemspec",
+    "VERSION",
+    "lib/ShyCouch.rb",
+    "test/helper.rb",
+    "test/old-test.rb",
+    "test/old-tests.rb",
+    "test/test_ShyCouch.rb",
+    "test/test_camping_integration.rb",
+    "test/test_couch_document.rb",
+    "test/test_couchdb_api.rb",
+    "test/test_couchdb_factory.rb",
+    "test/test_fields.rb"
+  ]
+  s.homepage = %q{http://github.com/Cerales/ShyCouch}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Ruby API for CouchDB, designed to work with the Camping micro-framework.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<sourcify>, ["~> 0.5.0"])
+      s.add_development_dependency(%q<ShyRubyJS>, [">= 0"])
+      s.add_runtime_dependency(%q<ShyRubyJS>, [">= 0"])
+      s.add_runtime_dependency(%q<sourcify>, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<sourcify>, ["~> 0.5.0"])
+      s.add_dependency(%q<ShyRubyJS>, [">= 0"])
+      s.add_dependency(%q<ShyRubyJS>, [">= 0"])
+      s.add_dependency(%q<sourcify>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<sourcify>, ["~> 0.5.0"])
+    s.add_dependency(%q<ShyRubyJS>, [">= 0"])
+    s.add_dependency(%q<ShyRubyJS>, [">= 0"])
+    s.add_dependency(%q<sourcify>, [">= 0"])
+  end
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/ShyCouch.rb

@@ -0,0 +1,358 @@
+# July 2011
+# This is a small Ruby layer for working with CouchDB
+# Built primarily to allow Camping apps to use CouchDB for data persistence 
+# ShyRubyJS is library used to build map and reduce functions from Ruby blocks
+
+require 'net/http'
+require 'json'
+require 'resolv'
+require 'shyrubyjs'
+
+module Kernel
+  def shycouch
+    $database = ShyCouch::Connection.Create
+  end
+end
+
+module ShyCouch
+  
+  attr_accessor :database
+  
+  class Connection
+    def self.Create(settings=nil)
+      settings = $settings unless settings
+      database = CouchDBAPI.new(settings["db"]["host"], settings["db"]["port"], settings["db"]["name"], settings["db"]["user"], settings["db"]["password"])
+      puts database.connect unless database.connect["ok"]
+      database.create unless database.on_server?
+      return database
+    end
+    
+    def push_generic_views
+      #TODO 
+    end
+  end
+
+  
+  module Data
+    class Model < Hash
+      # takes hash that will be the document contents as well as an array of expected keys for validation
+      # todo - enforce keys that work as attrs
+
+      def initialize(hash=nil, requirements)
+        @requirements = requirements
+        merge!(hash) if hash
+        raise TypeError unless valid? #TODO - should raise a more specific and useful error
+      end
+
+      def method_missing(name, *args)
+        # Makes the object behave as if the hash keys are instance properties with attr_accessors
+        if name.to_s
+          if name[name.length-1] == "="
+            key = name[0, name.length-1]
+            if self.key?(key)
+              self[key] = args
+              return args
+            end
+          else
+            return self[name.to_s] unless !self[name.to_s]
+          end
+        end
+        super
+      end
+      
+      def respond_to?(method)
+        # so that testing for whether it responds to a method is equivalent to testing for the existence of a key
+        return true if self.key?(method.to_s)
+        super
+      end
+    end
+    
+    class CouchDocument < Model
+      class << self
+        # allows instance.class.requirements to be called
+        attr_accessor :requirements
+      end
+      
+      def initialize(hash={})
+        # Assumes that the "kind" is the class name unless explicitly stated otherwise
+        # TODO - maybe just force it to be the class name no matter what tbh
+        hash["kind"] = self.class.to_s unless hash["kind"]
+        super(hash, @requirements)
+      end
+      
+      def self.all
+        database = CouchDatabase.new($settings)
+        database.get()
+      end
+      
+      def self.requires(*requirements)
+        @requirements = requirements
+      end
+      
+      def add_key(key, value=nil)
+        # The attr value assignment operator has been overriden, but it checks for the existence of a key.
+        # And therefore the user has to explicitly call this method first.
+        self[key] = value
+      end
+      
+      def attr_keys
+        # returns the keys for all the attrs that aren't the id or rev
+        attr_keys = []
+        self.map { |k,v|
+          attr_keys << k unless k == "_id" or k == "_rev"
+        }
+        return attr_keys
+      end
+      
+      def _requirements
+        #TODO - hm
+        return self.class.requirements
+      end
+      
+      def pull(database=nil)
+        database = $database unless database
+        new_doc = database.pull_document(self)
+        if new_doc
+          self.clear
+          self.merge! new_doc
+        end
+      end
+      
+      def push(database = nil)
+        # assumes $database unless it receives a database argument
+        database = $database unless database
+        res = database.push_document(self)
+        self["_id"] = res["id"]
+        self["_rev"] = res["rev"]
+        return res
+      end
+      
+      def valid?; to_json ? true : false; end
+      
+      def to_json
+        JSON::generate(self)
+      rescue JSON::GeneratorError
+        false
+      end
+    end
+  end
+
+  module Fields
+    #TODO - lightweight validation framework 
+    
+    class Email_Addr < String
+      def valid?
+        # Valid if: one and only one '@'; at least one "." after the '@'; an mx record can be resolved at the domain
+        valid_address? and valid_domain?
+      end
+      def valid_address?
+        self.split("@").length == 2 and self.split("@")[1].split(".").length >= 2
+        
+      end
+      def valid_domain?
+        domain = self.match(/\@(.+)/)[1]
+        Resolv::DNS.open { |dns| dns.getresources(domain, Resolv::DNS::Resource::IN::MX) }.size > 0 ? true : false
+        rescue Resolv::ResolvError
+          false
+      end
+    end
+  end
+
+  #TODO - split this stuff into modules too
+  class CouchDBAPI
+  	def initialize(host, port, name, user, password)
+  		@host, @port, @name, @user, @password = host, port, name, user, password
+  		@views = []
+  		@server = CouchServerConnection.allocate
+  	end
+    # 
+    # def initialize(*settings)
+    #   @host, @port, @name, @user, @password = settings["db"]["host"], settings["db"]["port"], settings["db"]["name"], settings["db"]["user"], settings["db"]["password"]
+    #     end
+
+  	attr_accessor :server, :name, :host, :port, :views
+
+  	def connect
+  		@server = CouchServerConnection.new({"host"=>@host, "port"=>@port, "user"=>@user, "password"=>@password})
+  		if @server.responds?
+  			return {"ok"=>true, "message"=>"Successfully connected to the couch database at #{@host}: #{@port}."}
+  		else
+  			return {"ok"=>false, "message"=>"Could not connect to the couch database."}
+  		end
+  	end
+  	def delete_database
+  	  @server.delete_db(self.name)
+	  end
+  	def server_responds?; return @server.responds?; end
+
+  	def on_server?
+  		@server.has_database?(@name)
+  	end
+
+  	def create
+  		@server.create_db(@name)
+  	end
+    def get_document(id)
+      @server.get_document(@name, id)
+    end
+    def all_docs
+      get_document('_all_docs').rows.map { |doc|
+        get_document(doc["id"])
+      }
+    end
+    def all_docs_with(attribute, value=nil)
+      #TODO - change this to build a couch map query, cache it in couch then call it
+      # maybe?!?!
+      docs = []
+      all_docs.each do |doc|
+        if value
+          docs << doc if doc[attribute] == value
+        else
+          docs << doc if doc[attribute]
+        end
+      end
+      return docs
+    rescue NameError
+    end
+    def uri
+      return "http://#{host}/#{port}/#{name}"
+    end
+
+    def pull_document(document)
+      @server.push_document(self.name, document)      
+    end
+
+    def push_document(document)
+      @server.push_document(self.name, document)
+    end
+    
+    def designs
+      @server.pull_all_design_docs(self.name)
+    end
+    
+    def views
+      designs.map{ |d| d["views"] }
+    end
+    
+    private 
+    class CouchServerConnection
+    	def initialize(args, options=nil)#host, port, user, password, options = nil)
+    		@host = args["host"]
+    		@port = args["port"]
+    		@user = args["user"]
+    		@password = args["password"]
+    		@options = options
+    	end
+
+    	def responds?
+    		if get('/')['couchdb'] == "Welcome"
+    			true
+    		else
+    			false
+    		end
+    	rescue Errno::ECONNREFUSED
+    		false
+    	end
+
+    	def has_database?(db_name)
+    		get("/#{db_name}/")
+    		true
+    	rescue RuntimeError => error
+    		false
+    	end
+
+    	#defining the get and delete methods
+    	['get', 'delete'].each do |name|
+    		define_method name do |uri|
+    			response = request(Net::HTTP.const_get(name.capitalize).new(uri)).body
+    			JSON.parse(response)
+    		end
+    	end
+
+    	def get_database_info(db_name)
+    		get("/#{db+name}/")	
+    	end
+
+      def pull_all_design_docs(db_name)
+        pull_all_doc_ids(db_name).map { get_document(db_name, id) if id[0,7] == "_design" }
+      end
+
+    	def pull_all_doc_ids(db_name)
+        get("/#{db_name}/_all_docs")["rows"].map { |doc| doc["id"] }
+    	end
+
+    	def all_docs_from_database(db_name)
+    	  pull_all_doc_ids(db_name).map { |id| Data::CouchDocument.new(get("/#{db_name}/#{id}")) }
+    	end
+
+    	def get_document(db_name, id)
+    		document = Data::CouchDocument.new(get("/#{db_name}/#{id}"))
+    	end
+
+    	def delete_document(db_name, id)
+    		delete("/#{db_name}/#{id}")
+    	end
+
+      # Haven't decided whether PUT/POST should take a CouchDocument or a JSON string.
+    	def put( uri, json = nil )
+    		#TODO - make this private
+    		req = Net::HTTP::Put.new(uri)
+    		req["content-type"] = "application/json"
+    		req.body = json unless json == nil
+    		JSON.parse(request(req).body)
+    	end
+  	
+    	def post(uri, json = nil)
+    	  # couch uses POST for new documents and gives them an ID
+    	  req = Net::HTTP::Post.new(uri)
+    	  req["content-type"] = "application/json"
+    	  req.body = json unless json == nil
+    	  JSON.parse(request(req).body)
+    	  #TODO - return success more meaningfully maybe?
+  	  end
+  	
+  	  def pull_document(db_name, document)
+    		document = Data::CouchDocument.new(get("/#{db_name}/#{id}"))  	    
+	    end
+  	
+    	def push_document(db_name, document)
+    	  raise TypeError unless document.class == Data::CouchDocument
+    	  raise JSON::GeneratorError unless document.valid?
+    	  if document["_rev"]
+    	    put("/#{db_name}/#{document._id}?rev=#{document._rev}/", document.to_json)
+  	    else
+  	      post("/#{db_name}/", document.to_json)
+  	    end
+  	  end
+
+    	def create_db(db_name)
+    		put("/#{db_name}/")
+    	end
+    	def delete_db(db_name)
+    		delete("/#{db_name}/")
+    	end
+
+    	def UUID
+    		get('/_uuids/')['uuids'][0]
+    	end
+
+    	private
+
+    	def handle_error(req, res)
+    		raise RuntimeError.new("#{res.code}:#{res.message}\nMETHOD:#{req.method}\nURI:#{req.path}\n#{res.body}")
+    	end
+
+    	def request(req)
+    		res = Net::HTTP.start(@host, @port) { |http|
+    		  req.basic_auth(@user, @password) if @user and @password
+    		  http.request(req)
+    		  }
+    		unless res.kind_of?(Net::HTTPSuccess)
+    			handle_error(req, res)
+    		end
+    		res
+    	end
+    end
+  
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ShyCouch'
+
+class Test::Unit::TestCase
+end

data/test/old-test.rb

@@ -0,0 +1,10 @@
+require '~/dev/shycouch/shycouch'
+require '~/dev/shycouch/shycouchtests'
+require 'irb'
+
+ShyCouchTests::test_up
+ShyCouchTests::test_down
+message = "Test methods: "
+message += ShyCouchTests::singleton_methods.map { |m| "ShyCouchTests::#{m}"}.join(', ')
+puts message
+IRB.start

data/test/old-tests.rb

@@ -0,0 +1,89 @@
+require '~/dev/shycouch/shycouch'
+module ShyCouchTests
+  def self.test_up
+    begin
+      # set everything up
+      $t_database, $t_id, $t_document = ShyCouch::CouchDatabase.allocate, "", ShyCouch::Data::CouchDocument.new
+
+      #set up the database
+      setup_database
+      setup_document
+      test_model
+      test_doc_kinds
+      # check that everything at least exists
+	    result = if $t_database and $t_database.server and $t_id and $t_document #and $test_doc_kinds.length == 1
+	      {"ok"=>true,"message"=>"Test environment appears to work","database"=>"$t_database",
+	        "server connection"=>"$t_database.server","test doc id"=>"$t_id", "test document"=>"$t_doc",
+	        "test doc model"=>"$t_model"}
+        else
+          {"ok"=>false,"message"=>"Test environment appears not to be working","database"=>$t_database,
+            "server connection"=>$t_database.server,"test doc id"=>$t_id,"test document"=>$t_doc}
+        end
+    rescue Errno::ECONNREFUSED
+	    result = {"ok"=>false, "message"=>"""Server Connection refused.
+	      Is CouchDB running at http://#{$t_database.host}:#{$t_database.port} ?"""}
+    end
+    result.each do |k, v| puts "#{k}: #{v}"; end
+    result["ok"]
+  end
+
+  def self.test_down
+    $t_database.server.delete_db('test')
+    $t_database = nil
+    $t_id = nil
+    $t_doc = nil
+    result = {"ok"=>true, "message"=>"Test environment has been brought down."}
+    result.each do|k, v| puts "#{k}: #{v}"; end
+  end
+
+  class TestModel < ShyCouch::Data::CouchDocument
+    def initialize hash
+      requirements = {
+        "me"=>String,
+        "you"=>Array
+      }
+      super hash, requirements
+    end
+  end
+
+  private
+
+  def self.setup_database
+    settings = {
+      "db"=> {
+          "host" => "localhost",
+          "port" => 5984,
+          "name" => "test",
+          "user" => "cerales",
+          "password" => "password"
+        },
+    }
+    $t_database = ShyCouch::Create.go(settings)
+    raise Errno::ECONNREFUSED unless $t_database.connect["ok"]
+    $t_database.create_on_server unless $t_database.exists_on_server?
+  end
+
+  def self.setup_document
+    if $t_database.all_docs.length == 0
+      emptyDoc = ShyCouch::Data::CouchDocument.new
+      #$t_id = $t_database.server.push_document($t_database, emptyDoc)["id"]
+      $t_id = $t_database.push_document(emptyDoc)["id"]
+    else
+      $t_id = $t_database.all_docs[0]["id"]
+    end
+  end
+
+  def self.test_doc_kinds
+    doc = ShyCouch::Data::CouchDocument.new.merge!("kind"=>"test")
+    doc2 = ShyCouch::Data::CouchDocument.new.merge!("kind"=>"nope")
+    doc3 = ShyCouch::Data::CouchDocument.new.merge!("kind"=>"not me!")
+    $t_database.push_document(doc)
+    $t_database.push_document(doc2)
+    $t_database.push_document(doc3)
+    $t_doc_kind = $t_database.all_docs_with("kind", "not me!")
+  end
+
+  def self.test_model
+    $t_document.merge!($t_database.get_document($t_id))
+  end
+end

data/test/test_ShyCouch.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch'
+
+# Most of these tests require a working CouchDB installation to be up and running.
+# All the tests that expect to work with the database will use the settings defined below.
+
+# Settings for a database that is set up and working, with an admin user
+$settings = {
+  "db"=> {
+      "host" => "localhost",
+      "port" => 5984,
+      "name" => "test",
+      "user" => "cerales",
+      "password" => "password"
+    },
+}
+
+# test ShyCouch::CouchDBAPI
+require_relative 'test_couchdb_api'
+
+# test ShyCouch::Fields
+# some of the tests in here are disabled cos they involve attempting to resolve a bad domain name
+require_relative 'test_fields'
+
+# test ShyCouch::Data::CouchDocument
+require_relative 'test_couch_document'
+
+require_relative 'test_camping_integration'

data/test/test_camping_integration.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch.rb'
+
+class CampingIntegrationTests
+  
+  class TestModelInheritence < Test::Unit::TestCase
+    
+    class InheritanceTest < ShyCouch::Data::CouchDocument; end
+    def test_document_kind_assignment
+         m = InheritanceTest.new
+         assert_equal(InheritanceTest.to_s, m.kind)
+    end
+    
+  end
+end

data/test/test_couch_document.rb

@@ -0,0 +1,141 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch.rb'
+
+class CouchDocumentTests# < Test::Unit::TestCase
+  
+  class TestDocumentCreation < Test::Unit::TestCase
+    def setup
+      valid_settings = $settings
+      @database = ShyCouch::Connection.Create(valid_settings)
+    end
+    def teardown
+      @database.delete_database
+      @database = nil
+    end
+
+    def test_create_from_empty_hash
+        # should be able to create a couch doc with a hash argument
+        hash = {}
+        couch_document = ShyCouch::Data::CouchDocument.new(hash)
+        assert_kind_of(ShyCouch::Data::CouchDocument, couch_document)
+    end
+  
+    def test_create_from_hash
+      # should be able to create a couch doc with a hash argument
+      hash = {"id" => "rejrandomrandomfhdjf", "rev"=>"1000000", "message"=>"up in here yo"}
+      couch_document = ShyCouch::Data::CouchDocument.new(hash)
+      assert_kind_of(ShyCouch::Data::CouchDocument, couch_document)
+    end
+  
+    def test_create_from_string
+      # Ensure no doc creation with fixnum argument
+      string = "hehe i'm all over here you know"
+      assert_raises IndexError do
+        doc = ShyCouch::Data::CouchDocument.new(string)
+      end
+    end
+  
+    def test_create_from_fixnum
+      # Ensure no doc creation with fixnum argument
+      fixnum = 1
+      assert_raises TypeError do
+        doc = ShyCouch::Data::CouchDocument.new(fixnum)
+      end
+    end
+    
+  end
+  
+  class TestDocumentPulling < Test::Unit::TestCase
+    #TODO
+  end
+  
+  class TestDocumentPushing < Test::Unit::TestCase
+    # assumes success of the stuff in TestDocumentPulling
+    def setup
+      valid_settings = $settings
+      $database = ShyCouch::Connection.Create(valid_settings)
+      
+      @valid_documents = [
+        ShyCouch::Data::CouchDocument.new({"kind"=>"post", "message"=>"BUY TRAMADOL ONLINE!!"}),
+        ShyCouch::Data::CouchDocument.new({"kind"=>"comment",
+            "message"=>"gry gry online gry gry online gry gry online gry gry online gry gry online "}),
+        ShyCouch::Data::CouchDocument.new({"kind"=>"tag", "name"=>"FREE CANADIAN PRESCRIPTION DRUGS"}),
+        ShyCouch::Data::CouchDocument.new({"kind"=>"helpers", 
+            "helpers"=>["helper", "bad helper", "terrible helper", "this isn't helping"],
+            "actually_helpful"=>false, "times_helped"=>0}),
+        ]
+      @existing_valid_documents = [
+        ShyCouch::Data::CouchDocument.new("whatever"=>"yep"),
+        ShyCouch::Data::CouchDocument.new("is_a_document"=>true, "number_of_docs_this_is"=>1)
+      ].each { |doc|
+        doc.push
+      }
+      @invalid_documents = nil # make sure user can't set rev maybe? or is that legal?
+    end
+    def teardown
+      $database.delete_database
+      $database = nil
+      # delete the database
+    end
+    
+    def test_keys_as_attr_accessors
+      # tests that if there is a "phone" key on "doc" object you can do doc.phone
+      @valid_documents.each { |doc| 
+        doc.keys.each { |key|
+          assert_respond_to(doc, key)
+        }
+      }
+    end
+    
+    def test_push_new_documents
+      @valid_documents.each { |doc|
+        # put the document on the server, grab the server's response
+        res = doc.push
+        # check that the server included "ok"=>true in its response
+        assert(res["ok"])
+        # check that the doc now has an id and a rev
+        assert(doc["_id"])
+        assert(doc["_rev"])
+        # get the new doc
+        newDoc = $database.get_document(doc._id)
+        # test equality of all the attributes aside from id and rev on the new document
+        doc.attr_keys.each { |k|
+          assert_equal(doc["k"], newDoc["k"])
+        }
+      }
+    end
+    
+    def test_change_existing_documents
+      @existing_valid_documents.each { |doc| 
+        # add some more attributes
+        assert(doc._rev)
+        doc.add_key("owner", "the guvvmint")
+        doc.add_key("buttonCount")
+        doc.add_key("friends")
+        doc.buttonCount = 5
+        doc.friends = ["alan", "alex", "all me other mates"]
+        
+        res = doc.push
+        assert(res["ok"])
+        
+        # pull it from the database again
+        checkDoc = $database.get_document(doc._id)
+        
+        # check that the one from the database has all the new attributes
+        assert_equal(doc.owner, checkDoc.owner)
+        assert_equal(doc.buttonCount, checkDoc.buttonCount)
+        assert_equal(doc.friends, checkDoc.friends)
+      }
+    end
+  
+    def test_illegal_change_to_rev
+      @existing_valid_documents.each { |doc|
+        doc._rev = "hurr"
+        assert_raises RuntimeError do
+          res = doc.push
+        end
+      }
+    end
+    
+  end
+end

data/test/test_couchdb_api.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch.rb'
+
+class TestCouchDBAPI < Test::Unit::TestCase
+  def setup
+    valid_settings = $settings
+    $database = ShyCouch::Connection.Create(valid_settings)
+  end
+  
+  def teardown
+    $database.delete_database
+    $database = nil
+  end
+  
+  def test_connection
+    assert_equal(true, $database.connect["ok"])
+  end
+end

data/test/test_couchdb_factory.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch.rb'
+
+class TestCouchDBFactory < Test::Unit::TestCase
+  def setup
+    @valid_settings = $settings
+  end
+  
+  def teardown
+  end
+  
+  def test_create_database
+    assert_kind_of(ShyCouch::CouchDBAPI, ShyCouch::Create.go(@valid_settings))
+  end
+end

data/test/test_fields.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require_relative '../lib/ShyCouch.rb'
+
+class TestEmailField < Test::Unit::TestCase
+  def setup
+    @valid_emails = ['bigbeggar@gmail.com', 'helpmeout@bigpond.com'] # more!
+    @invalid_emails = ['byby.head@heat']#, 'looptheloop@ireallyhopethisisntadomainpleasedontbeadomain.org'] # more!
+    #commented out the one with an invalid domain cos resolve timeout long
+  end
+  
+  def teardown; end
+  
+  def test_valid_emails
+    @valid_emails.each do |email|
+      email_addr = ShyCouch::Fields::Email_Addr.new(email)
+      assert_equal(true, email_addr.valid?)
+    end
+  end
+  
+  def test_invalid_emails
+    @invalid_emails.each do |email|
+       email_addr = ShyCouch::Fields::Email_Addr.new(email)
+       assert_equal(false, email_addr.valid?)
+     end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: ShyCouch
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Shy Inc.
+- Daniel Bryan
+- Cerales
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70299706365800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70299706365800
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70299706364960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70299706364960
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70299706364040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70299706364040
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: &70299706363060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *70299706363060
+- !ruby/object:Gem::Dependency
+  name: ShyRubyJS
+  requirement: &70299706361900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70299706361900
+- !ruby/object:Gem::Dependency
+  name: ShyRubyJS
+  requirement: &70299706360460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70299706360460
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: &70299706359260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70299706359260
+description: Ruby API for CouchDB, designed to work with the Camping micro-framework.
+email: danbryan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- ShyCouch.gemspec
+- VERSION
+- lib/ShyCouch.rb
+- test/helper.rb
+- test/old-test.rb
+- test/old-tests.rb
+- test/test_ShyCouch.rb
+- test/test_camping_integration.rb
+- test/test_couch_document.rb
+- test/test_couchdb_api.rb
+- test/test_couchdb_factory.rb
+- test/test_fields.rb
+homepage: http://github.com/Cerales/ShyCouch
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2260560036860812579
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby API for CouchDB, designed to work with the Camping micro-framework.
+test_files: []