loose_change 0.3.1

data/lib/loose_change/errors.rb

@@ -0,0 +1,7 @@
+module LooseChange
+  module Errors
+
+    attr_accessor :errors
+
+  end
+end

data/lib/loose_change/helpers.rb

@@ -0,0 +1,10 @@
+module LooseChange
+  module Helpers
+    def default_headers
+      {
+        :content_type => :json,
+        :accept       => :json
+      }
+    end
+  end
+end

data/lib/loose_change/naming.rb

@@ -0,0 +1,11 @@
+module LooseChange
+  module Naming
+    include ActiveModel::Naming
+  end
+  
+  module NamingClassMethods
+    def model_name
+      self.class.model_name
+    end
+  end
+end

data/lib/loose_change/pagination.rb

@@ -0,0 +1,69 @@
+module LooseChange
+
+  module Pagination
+
+    # Similar to <tt>#view_by</tt>, but adds a paginated view
+    # compatible with <tt>will_paginate</tt>.
+    def paginated_view_by(*keys)
+      view_name = "paginated_by_#{ keys.join('_and_') }"
+      map_code = "function(doc) {
+                     if ((doc['model_name'] == '#{ model_name }') && #{ keys.map {|k| existence_check k}.join('&&') }) {
+                       emit(#{ key_for(keys) }, 1)
+                     }
+                   }
+                   "
+      reduce_code = "function(keys, values) { return sum(values); }"
+      add_view(view_name, map_code, reduce_code)
+      view_by(*keys)
+    end
+
+    # Returns a <tt>will_paginate</tt>-compatible set of documents.
+    # In +opts+, <tt>:per_page</tt> is required, and <tt>:page</tt>
+    # will be set to 1 unless otherwise specified.  All other +opts+
+    # will be passed to CouchDB as in <tt>:view_by</tt>.
+    def paginated_by(view_name, opts = {})
+      raise "You must include a per_page parameter" if opts[:per_page].nil?
+
+      opts[:page] ||= 1
+
+      WillPaginate::Collection.create( opts[:page], opts[:per_page] ) do |pager|
+        total_result = view("paginated_by_#{ view_name }", :reduce => true)
+        pager.total_entries = total_result ? total_result.first : 0
+
+        results = if view_name == :all
+                    view(view_name, :limit => opts[:per_page], :skip => ((opts[:page].to_i - 1) * opts[:per_page].to_i), :include_docs => true)
+                  else
+                    view("by_#{ view_name }", :key => opts[:key],  :limit => opts[:per_page], :skip => ((opts[:page].to_i - 1) * opts[:per_page].to_i), :include_docs => true)
+                  end
+        pager.replace( results )
+      end
+    end
+
+    # Short for <tt>paginated_by(:all)</tt>; see
+    # <tt>#paginated_by</tt> for +opts+.
+    def paginate(opts = {})
+      paginated_by(:all, opts)
+    end
+    
+    private
+    
+    def paginated_view_by_all
+      view_name = "paginated_by_all"
+      map_code = "function(doc) {
+                     if (doc['model_name'] == '#{ model_name }') {
+                       emit(null, 1);
+                     }
+                   }
+                   "
+      reduce_code = "function(keys, values) { return sum(values); }"
+      add_view(view_name, map_code, reduce_code)
+    end
+    
+    def existence_check(key)
+      "(#{ doc_key(key) } != null)"
+    end
+    
+  end
+  
+
+end

data/lib/loose_change/persistence.rb

@@ -0,0 +1,154 @@
+require 'cgi'
+
+module LooseChange
+  module Persistence
+    
+    # Set the database source for this model, named +db+ on +server+
+    # (http://localhost:5984 by default).  If the database does not
+    # exist, it will be added.
+    def use_database(db, server = "http://127.0.0.1:5984")
+      self.database = Database.new(db, Server.new(server))
+      Database.setup_design(self.database, self.model_name)
+      view_by_all
+      paginated_view_by_all
+    end
+
+    # Retrieve a document from CouchDB with id +id+ as a Loose Change instance.
+    def find(id)
+      begin
+        result = JSON.parse(RestClient.get(self.database.uri + "/#{ id }"), default_headers)
+      rescue RestClient::ResourceNotFound
+        raise RecordNotFound
+      end
+      raise RecordNotFound unless result['model_name'] == model_name
+      instantiate_from_hash(result)
+    end
+
+    # Instantiate a new Loose Change record with attributes +args+ and
+    # immediately save to the database.
+    def create(args = {})
+      model = new(args)
+      model.save
+      model
+    end
+    
+    # Instantiate a new Loose Change record with attributes +args+ and
+    # immediately save to the database.  If the record is invalid, a
+    # <tt>RecordInvalid</tt> error will be thrown.
+    def create!(args = {})
+      new(args).save!
+    end
+
+    # Build a Loose Change record from a hash of attributes +hash+ as
+    # returned by CouchDB.
+    def instantiate_from_hash(hash)
+      model = new(hash.reject {|k, _| 'model_name' == k || '_attachments' == k})
+      model.id = hash['_id']
+      model.new_record = false
+      if hash['_attachments']
+        attachment_names = hash['_attachments'].map {|name, _| name}
+        model.attachments = attachment_names.inject({}) {|acc, name| acc[name.to_sym] = {:content_type => hash['_attachments'][name]['content_type']}; acc}
+      end
+      model
+    end
+    
+  end
+  
+  module PersistenceClassMethods
+
+    attr_accessor :new_record, :destroyed, :database, :id, :_rev, :_id
+    
+    def new_record?()   @new_record end
+    def destroyed?()    @destroyed  end
+    
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    # Persist the record to CouchDB, including saving of any attachments.
+    def save
+      if new_record?
+        _run_create_callbacks { _run_save_callbacks { _save } }
+      else
+        _run_save_callbacks { _save }
+      end
+    end
+    
+    # Persist the record to CouchDB, including saving of any
+    # attachments. If the record is not valid, a
+    # <tt>RecordInvalid</tt> error will be thrown.
+    def save!
+      if new_record?
+        _run_create_callbacks { _run_save_callbacks { _save! } }
+      else
+        _run_save_callbacks { _save! }
+      end
+    end
+    
+    # Destroy the record on CouchDB by sending an HTTP DELETE request.
+    def destroy
+      _run_destroy_callbacks do
+        raise DatabaseNotSet.new("Cannot destroy without database set.") unless @database
+        result = JSON.parse(RestClient.delete("#{ database.uri }/#{ CGI.escape(id) }?rev=#{ @_rev }", default_headers))['ok']
+        @destroyed = result
+      end
+    end
+    
+    private
+
+    def _save
+      raise DatabaseNotSet.new("Cannot save without database set.") unless @database
+      apply_defaults
+      return false unless valid?
+      new_record? ? post_record : put_record
+      put_attachments
+      self
+    end
+    
+    def _save!
+      raise RecordInvalid, self.errors.map {|k, v| "#{k.capitalize} #{v}"}.join(', ') unless _save
+      self
+    end
+    
+    def uri
+      "#{database.uri}/#{ CGI.escape(id) }"
+    end
+    
+    def post_record
+      result = JSON.parse(RestClient.post(database.uri, self.to_json(:methods => [:model_name]), default_headers))
+      @id = @_id = result['id']
+      @_rev = result['rev']
+      @new_record = false
+      result
+    end
+
+    def put_record
+      result = JSON.parse(RestClient.put(uri, self.to_json(:methods => [:model_name, :_rev, :_id], :except => [:id]), default_headers))
+      @_rev = result['rev']
+      result
+    end
+
+    def put_attachments
+      (@attachments || {}).each { |name, attachment| put_attachment(name) if attachment[:dirty] }
+    end
+    
+    def attachment_ivar(name)
+      instance_variable_get("@#{ name }")
+    end
+
+    def attachment_content_type(name)
+      instance_variable_get("@_#{ name }_content_type")
+    end
+    
+  end
+
+  class RecordNotFound < Exception
+  end
+
+  class DatabaseNotSet < Exception
+  end
+  
+  class RecordInvalid < Exception
+  end
+  
+end

data/lib/loose_change/server.rb

@@ -0,0 +1,11 @@
+module LooseChange
+  class Server
+    
+    attr_accessor :uri
+
+    def initialize(server = "http://127.0.0.1:5984")
+      @uri = server
+    end
+
+  end
+end

data/lib/loose_change/views.rb

@@ -0,0 +1,99 @@
+require 'cgi'
+
+module LooseChange
+  module Views
+    
+    # Invoke a view identified by +view_name+ on this Loose Change
+    # model's design document on CouchDB. Options specified in the
+    # +opts+ hash will be passed along to CouchDB; for options see
+    # http://wiki.apache.org/couchdb/Introduction_to_CouchDB_views
+    def view(view_name, opts = {})
+      opts[:key] = opts[:key] ? CGI.escape(opts[:key].to_json) : nil
+      param_string = opts.reject {|k,v| v.nil?}.map {|k,v| "#{k}=#{v}"}.join('&')
+      JSON.parse(RestClient.get("#{ self.database.uri }/_design/#{ CGI.escape(self.model_name) }/_view/#{ view_name }?#{ param_string }", default_headers))['rows'].map do |row|
+        opts[:include_docs] ? instantiate_from_hash(row['doc']) : row['value']
+      end
+    end
+
+    # Set up a view that will allow you to query CouchDB by +keys+.  A
+    # view will be added to the design document on CouchDB, and a
+    # method to retrieve documents will be added to the Loose Change
+    # model class.
+    #
+    #   class Recipe < LooseChange::Base
+    #     property :name
+    #     property :popularity
+    #     view_by :name
+    #     view_by :name, :popularity
+    #   end
+    #
+    #   Recipe.by_name("lasagne")
+    #   Recipe.by_name_and_popularity("lasagne", 4)
+    def view_by(*keys)
+      view_name = "by_#{ keys.join('_and_') }"
+      view_code = "function(doc) {
+                     if ((doc['model_name'] == '#{ model_name }') && #{ keys.map {|k| existence_check k}.join('&&') }) {
+                       emit(#{ key_for(keys) }, null)
+                     }
+                   }
+                   "
+      add_view(view_name, view_code)
+      self.class.send(:define_method, view_name.to_sym) do |*keys|
+        keys = keys.first if keys.length == 1
+        view(view_name, :key => keys, :include_docs => true)
+      end
+    end
+    
+    # Retrieve all of this model's documents currently stored on CouchDB.
+    def all(opts = {})
+      view(:all, opts.merge!(:include_docs => true))
+    end
+
+    # Add a view to the this model's design document on CouchDB.  The
+    # view is identified by +name+, defined by +map+ and optionally
+    # +reduce+, which are composed of JavaScript functions.  For more
+    # information on CouchDB views, see
+    # http://wiki.apache.org/couchdb/Introduction_to_CouchDB_views 
+    def add_view(name, map, reduce = nil)
+      design_doc = JSON.parse(RestClient.get("#{ self.database.uri }/_design/#{ CGI.escape(self.model_name) }"))
+      current_views = design_doc['views'] || {}
+      JSON.parse(RestClient.put("#{ self.database.uri }/_design/#{ self.model_name }",
+                                { '_id' => design_doc['_id'],
+                                  '_rev' => design_doc['_rev'],
+                                  'language' => 'javascript',
+                                  'views' => current_views.merge({name => {'map' => map, 'reduce' => reduce}})}.to_json, default_headers))
+    end
+    
+    #:nodoc:
+    def view_by_all
+      view_name = "all"
+      view_code = "function(doc) {
+                     if (doc['model_name'] == '#{ model_name }') {
+                       emit(null);
+                     }
+                   }
+                   "
+      add_view(view_name, view_code)
+    end
+
+    #:nodoc:
+    def existence_check(key)
+      "(#{ doc_key(key) } != null)"
+    end
+    
+    #:nodoc:
+    def key_for(keys)
+      if keys.length == 1
+        doc_key(keys.first)
+      else
+        "[#{keys.map {|k| doc_key(k) }.join(',')}]"
+      end
+    end
+    
+    #:nodoc:
+    def doc_key(key)
+      "doc['#{ key }']"
+    end
+    
+  end
+end

data/loose_change.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{loose_change}
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Joshua Miller"]
+  s.date = %q{2010-11-24}
+  s.email = %q{josh@joshinharrisburg.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/loose_change.rb",
+     "lib/loose_change/attachments.rb",
+     "lib/loose_change/attributes.rb",
+     "lib/loose_change/base.rb",
+     "lib/loose_change/database.rb",
+     "lib/loose_change/errors.rb",
+     "lib/loose_change/helpers.rb",
+     "lib/loose_change/naming.rb",
+     "lib/loose_change/pagination.rb",
+     "lib/loose_change/persistence.rb",
+     "lib/loose_change/server.rb",
+     "lib/loose_change/views.rb",
+     "loose_change.gemspec",
+     "test/attachment_test.rb",
+     "test/attributes_test.rb",
+     "test/base_test.rb",
+     "test/callback_test.rb",
+     "test/inheritance_test.rb",
+     "test/pagination_test.rb",
+     "test/persistence_test.rb",
+     "test/resources/couchdb.png",
+     "test/test_helper.rb",
+     "test/view_test.rb"
+  ]
+  s.homepage = %q{http://github.com/joshuamiller/loose_change}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{ActiveModel-compliant CouchDB ORM}
+  s.test_files = [
+    "test/attachment_test.rb",
+     "test/attributes_test.rb",
+     "test/base_test.rb",
+     "test/callback_test.rb",
+     "test/inheritance_test.rb",
+     "test/pagination_test.rb",
+     "test/persistence_test.rb",
+     "test/test_helper.rb",
+     "test/view_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<activemodel>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<rest-client>, ["~> 1.6.0"])
+      s.add_runtime_dependency(%q<json>, ["~> 1.4.6"])
+    else
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
+      s.add_dependency(%q<rest-client>, ["~> 1.6.0"])
+      s.add_dependency(%q<json>, ["~> 1.4.6"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+    s.add_dependency(%q<activemodel>, ["~> 3.0.0"])
+    s.add_dependency(%q<rest-client>, ["~> 1.6.0"])
+    s.add_dependency(%q<json>, ["~> 1.4.6"])
+  end
+end
+