loose_change 0.3.1

data/.gitignore

@@ -0,0 +1,2 @@
+.rvmrc
+.bundle

data/Gemfile

@@ -0,0 +1,17 @@
+source 'http://rubygems.org'
+
+gem 'activesupport', '~> 3.0.0'
+gem 'activemodel', '~> 3.0.0'
+gem 'rest-client'
+gem 'json'
+gem 'will_paginate'
+
+group :development do
+  gem 'jeweler'
+  gem 'rake'
+end
+
+group :test do
+  gem 'shoulda'
+  gem 'timecop'
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activesupport (3.0.0)
+    builder (2.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    i18n (0.4.1)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json (1.4.6)
+    json_pure (1.4.6)
+    mime-types (1.16)
+    rake (0.8.7)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    shoulda (2.11.3)
+    timecop (0.3.5)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 3.0.0)
+  activesupport (~> 3.0.0)
+  jeweler
+  json
+  rake
+  rest-client
+  shoulda
+  timecop
+  will_paginate

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Joshua Miller
+
+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,39 @@
+# Loose Change is a Ruby ORM for CouchDB
+
+* where 'ORM' is as accurate as ['Holy Roman
+Empire'](http://en.wikipedia.org/wiki/Holy_Roman_Empire#Analysis)
+
+## Goals and Principles
+
+* Take advantage of
+  [ActiveModel](http://yehudakatz.com/2010/01/10/activemodel-make-any-ruby-object-feel-like-activerecord/)
+* Make common tasks easy; get out of your way if you need the metal
+* Make working with [GeoCouch](http://github.com/vmx/couchdb) seamless
+
+## Warnings
+
+* This is pretty alpha at this point.
+* Only tested on Ruby 1.9.2.  I'm not intentionally breaking 1.8.x, but neither do I guarantee anything.
+* The stuff about GeoCouch above was a goal I didn't get to yet.
+
+## Help
+
+* Accepted. Fork at
+  [Github](http://github.com/joshuamiller/loose_change)
+
+## Shoulders of Giants
+
+Inspiration and help from:
+
+* [RestClient](http://github.com/archiloque/rest-client), for the
+  basic HTTP plumbing.
+* [CouchRest](http://github.com/couchrest/couchrest), for the idea and
+  basic structure of using RestClient to talk to CouchDB.
+* [CouchRest-Rails](http://github.com/hpoydar/couchrest-rails), for
+  implementation ideas for interacting with Rails.
+* [will_paginate](http://github.com/mislave/will_paginate), for making
+  pagination a dead-simple addition.
+
+## License
+
+* MIT.  See LICENSE for more details.

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  Bundler.require(:test)
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+begin
+  Bundler.require :development
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "loose_change"
+    gemspec.summary = "ActiveModel-compliant CouchDB ORM"
+    gemspec.email = "josh@joshinharrisburg.com"
+    gemspec.homepage = "http://github.com/joshuamiller/loose_change"
+    gemspec.authors = ["Joshua Miller"]
+    # Dependencies
+    gemspec.add_dependency 'activesupport', '~> 3.0.0'
+    gemspec.add_dependency 'activemodel', '~> 3.0.0'
+    gemspec.add_dependency 'rest-client', '~> 1.6.0'
+    gemspec.add_dependency 'json', '~> 1.4.6'
+  end
+  Jeweler::GemcutterTasks.new  
+rescue LoadError
+  puts "Jeweler not available."
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.3.1

data/lib/loose_change.rb

@@ -0,0 +1,23 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_model'
+require 'rest-client'
+require 'json'
+require 'will_paginate'
+require 'will_paginate/collection'
+
+module LooseChange
+  extend ActiveSupport::Autoload
+
+  autoload :Attributes, File.dirname(__FILE__) + '/loose_change/attributes'
+  autoload :Attachments, File.dirname(__FILE__) + '/loose_change/attachments'
+  autoload :Errors, File.dirname(__FILE__) + '/loose_change/errors'
+  autoload :Naming, File.dirname(__FILE__) + '/loose_change/naming'
+  autoload :Base, File.dirname(__FILE__) + '/loose_change/base'
+  autoload :Persistence, File.dirname(__FILE__) + '/loose_change/persistence'
+  autoload :Database, File.dirname(__FILE__) + '/loose_change/database'
+  autoload :Server, File.dirname(__FILE__) + '/loose_change/server'
+  autoload :Views, File.dirname(__FILE__) + '/loose_change/views'
+  autoload :Pagination, File.dirname(__FILE__) + '/loose_change/pagination'
+  autoload :Helpers, File.dirname(__FILE__) + '/loose_change/helpers'
+end

data/lib/loose_change/attachments.rb

@@ -0,0 +1,60 @@
+module LooseChange
+  
+  module Attachments
+  end
+
+  module AttachmentClassMethods
+    
+    # Attach a file to this model, to be stored inline in
+    # CouchDB.  Note that the file will not actually be transferred
+    # to CouchDB until #save is called. The +name+ parameter will be
+    # used on CouchDB and in Loose Change to retrieve the attachment
+    # later. If you set the <tt>:content_type</tt> key in the optional +args+
+    # hash, that content-type will be set on the attachment in CouchDB
+    # and available when the model is retrieved.
+    #
+    #   recipe = Recipe.create!(:name => "Lasagne")
+    #   recipe.attach(:photo, File.open("lasagne.png"), :content_type
+    #   => 'image/png'
+    #   recipe.save
+    def attach(name, file, args = {})
+      attachment = args.merge :file => file, :dirty => true
+      @attachments = (@attachments || {}).merge(name => attachment)
+    end
+    
+    # Returns the file identified by +name+ on a Loose Change model
+    # instance, whether or not that file has been saved back to
+    # CouchDB.  Will return nil if no attachment by that name exists.
+    def attachment(name)
+      return attachments[name][:file] if @attachments.try(:[], :name).try(:[], :file)
+      begin
+        result = retrieve_attachment(name)
+        @attachments = (@attachments || {}).merge(name => {:file => result[:file], :dirty => false, :content_type => result[:content_type]})
+        result[:file]
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+    end
+
+    # Returns a hash composed of <tt>file</tt> and <tt>content_type</tt> as
+    # returned from CouchDB identified by +name+.
+    def retrieve_attachment(name)
+      { :file => RestClient.get("#{ uri }/#{ name }"),
+        :content_type => JSON.parse(RestClient.get(uri))['_attachments']['name'] }
+    end
+    
+    # Explicitly transfers an attachment to CouchDB without saving the
+    # rest of the model.
+    #
+    #   recipe.attach(:photo, File.open("lasagne.png"), :content_type
+    #   => 'image/png'
+    #   recipe.put_attachment(:photo)
+    def put_attachment(name)
+      return unless attachments[name]
+      result = JSON.parse(RestClient.put("#{ uri }/#{ name }#{ '?rev=' + @_rev if @_rev  }", attachments[name][:file], {:content_type => attachments[name][:content_type], :accept => 'text/json'}))
+      @_rev = result['rev']
+    end
+    
+  end
+  
+end

data/lib/loose_change/attributes.rb

@@ -0,0 +1,79 @@
+module LooseChange
+  
+  module Attributes
+    
+    # Set a field to be stored in a CouchDB document.  Any
+    # JSON-encodable value can be used; there is no explicit typing.
+    # The <tt>:default</tt> option can be used to always store a value
+    # on documents where this property has not been set.
+    #
+    #   class Recipe < LooseChange::Base
+    #     property :name
+    #     property :popularity, :default => 0
+    #   end
+    def property(name, opts = {})
+      attr_accessor name.to_sym
+      self.properties = ((self.properties || []) << name.to_sym)
+      default(name.to_sym, opts[:default]) if opts[:default]
+      define_attribute_methods [name]
+    end
+    
+    #:nodoc:
+    def default(property, value)
+      self.defaults ||= {}
+      self.defaults[property] = value
+    end
+
+    # Automatically set up <tt>:created_at</tt> and
+    # <tt>:updated_at</tt> properties which are set on creation and
+    # save, respectively.
+    def timestamps!
+      property :created_at
+      property :updated_at
+      
+      before_create :touch_created_at
+      before_create :touch_updated_at
+      before_save :touch_updated_at
+    end
+  end
+
+  module AttributeClassMethods
+
+    # Returns a hash of property names and current values.
+    def attributes
+      (self.class.properties || []).inject({}) {|acc, key| acc[key] = send(key); acc}
+    end
+    
+    # Change the value of a property and save the result to CouchDB.
+    def update_attribute(name, value)
+      send("#{name}=", value)
+      save
+    end
+    
+    # Change multiple properties at once with a hash of property names
+    # and values, then save the result to CouchDB.
+    def update_attributes(args = {})
+      args.each do |name, value|
+        send("#{name}=", value)
+      end
+      save
+    end
+    
+    private
+    
+    def touch_created_at
+      self.created_at = Time.now
+    end
+
+    def touch_updated_at
+      self.updated_at = Time.now
+    end
+        
+    def apply_defaults
+      (self.class.defaults || {}).each do |property, value|
+        self.send("#{property}=", self.send(property) || value)
+      end
+    end
+  end
+  
+end

data/lib/loose_change/base.rb

@@ -0,0 +1,71 @@
+module LooseChange
+  class Base
+    
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Dirty
+    
+    # Can't escape the following when trying to
+    # use a Callbacks module:
+    # undefined method `extlib_inheritable_reader' for LooseChange::Callbacks:Module
+    # so we'll throw it in here
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create, :save, :destroy
+    
+    extend Attributes
+    include AttributeClassMethods
+    extend Attachments
+    include AttachmentClassMethods
+    extend Naming
+    include NamingClassMethods
+    include Errors
+    extend Persistence 
+    include PersistenceClassMethods
+    extend Views
+    extend Pagination
+    include Helpers
+    extend Helpers
+    
+    class_inheritable_accessor :database, :properties, :defaults
+    attr_accessor :attachments
+    
+    def to_key
+      persisted? ? [id] : nil
+    end
+    
+    def to_model
+      self
+    end
+
+    def to_param
+      (to_key && persisted?) ? to_key.join('-') : nil
+    end
+        
+    def ==(other_model)
+      return false unless other_model && other_model.is_a?(self.class)
+      id == other_model.id &&
+        _rev == other_model._rev &&
+        !(changed? || other_model.changed?)
+    end
+    
+    alias_method :eql?, :== 
+    
+    def hash
+      id.try(:hex) || super
+    end
+    
+    def initialize(args = {})
+      @errors = ActiveModel::Errors.new(self)
+      @database = self.database
+      @new_record = true unless args['_id']
+      args.each {|property, value| self.send("#{property}=".to_sym, value)}
+      apply_defaults
+      self
+    end
+    
+  end
+end
+
+LooseChange::Base.include_root_in_json = false

data/lib/loose_change/database.rb

@@ -0,0 +1,52 @@
+require 'cgi'
+
+module LooseChange
+  class Database
+    include Helpers
+    extend Helpers
+    
+    attr_reader :server, :name
+    
+    # Build a new LooseChange::Database instance with a database named
+    # +name+.  The +server+ is a URI string identifying the CouchDB
+    # server and port.  If the database does not exist on the server,
+    # it will be created.
+    def initialize(name, server)
+      @name = name
+      @server = server
+      @uri  = "/#{name.gsub('/','%2F')}"
+      create_database_unless_exists
+    end
+    
+    def uri
+      server.uri + @uri
+    end
+
+    # Delete the database named +name+ on the server +server+.
+    def self.delete(name, server = "http://127.0.0.1:5984")
+      begin
+        RestClient.delete("#{ server }/#{ name }")
+      rescue RestClient::ResourceNotFound
+      end
+    end
+        
+    def self.setup_design(database, model_name)
+      begin
+        RestClient.get("#{ database.uri }/_design/#{ CGI.escape(model_name) }")
+      rescue
+        RestClient.put("#{ database.uri }/_design/#{ CGI.escape(model_name) }",
+                       { '_id' => "_design/#{ CGI.escape(model_name) }",
+                         'language' => 'javascript'}.to_json, default_headers)
+      end
+    end
+    
+    private
+    
+    def create_database_unless_exists
+      unless JSON.parse(RestClient.get("#{server.uri}/_all_dbs", default_headers)).include?(name)
+        RestClient.put uri, "", default_headers
+      end
+    end
+    
+  end
+end