simply_stored 0.1.12 → 0.1.13

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+Changelog
+=============
+
+0.1.13
+=============
+
+- Please delete all your design documents!
+- Auto-generate count-methods for has_many associations, e.g
+
+    class Blog
+      include SimplyStored::Couch
+      has_many :posts
+    end
+    
+    class Post
+      include SimplyStored::Couch
+      belongs_to :blog
+    end
+    
+    blog = Blog.create
+    blog.post_count
+    # => 0
+    
+    Post.create(:blog => blog)
+    blog.post_count(:force_reload => true)
+    # => 1

data/LICENSE.txt

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2010 Peritor GmbH <info@peritor.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */

data/README.md

@@ -0,0 +1,221 @@
+Convenience layer for CouchDB and SimpleDB. Requires CouchPotato and RightAWS library respectively.
+
+SimplyStored allows you to persist your objects to CouchDB (or SimpleDB) using an ActiveRecord-like syntax.
+
+In contrast to [CouchPotato](http://github.com/langalex/couch_potato) (on top of it is build) 
+it supports associations and other syntactic sugar that makes ActiveRecord so appealing. 
+
+Both backends have also support for S3 attachments.
+
+See also [RockingChair](http://github.com/jweiss/rocking_chair) on how to speed-up your unit tests 
+by using an in-memory CouchDB backend.
+
+Installation
+============
+
+    gem install simply_stored
+
+Usage
+=============
+
+Require the SimplyStored and decide with backend you want (CouchDB or SimpleDB).
+
+    require 'simply_stored/couch'
+    CouchPotato::Config.database_name = "http://example.com:5984/name_of_the_db"
+    
+or
+
+    require 'simply_stored/simpledb'
+    SimplyStored::Simple.aws_access_key = 'foo'
+    SimplyStored::Simple.aws_secret_access_key = 'bar'
+    RightAws::ActiveSdb.establish_connection(SimplyStored::Simple.aws_access_key, SimplyStored::Simple.aws_secret_access_key, :protocol => 'https')
+    
+From now on you can define classes that use SimplyStored.
+
+CouchDB - Intro
+=============
+
+The CouchDB backend is better supported and has more features. It auto-generates views for you and handles 
+all the serialization and de-serialization stuff.
+
+    class User
+      include SimplyStored::Couch
+      
+      property :login
+      property :age
+      property :accepted_terms_of_service, :type => :boolean
+      property :last_login, :type => Time
+    end
+
+    user = User.new(:login => 'Bert', :age => 12, :accepted_terms_of_service => true, :last_login = Time.now)
+    user.save
+    
+    User.find_by_age(12).login
+    # => 'Bert'
+    
+    User.all
+    # => [user]
+    
+    class Post
+      include SimplyStored::Couch
+      
+      property :title
+      property :body
+      
+      belongs_to :user
+    end
+    
+    class User
+      has_many :posts
+    end
+    
+    post = Post.create(:title => 'My first post', :body => 'SimplyStored is so nice!', :user => user)
+    
+    user.posts
+    # => [post]
+    
+    Post.find_all_by_title_and_user_id('My first post', user.id).first.body
+    # => 'SimplyStored is so nice!'
+    
+    post.destroy
+    
+    user.posts(:force_reload => true)
+    # => []
+
+    
+CouchDB - Associations
+=============
+    
+The supported associations are: belongs_to, has_one, has_many, and has_many :through
+    
+    class Post
+      include SimplyStored::Couch
+      
+      property :title
+      property :body
+      
+      has_many :posts, :dependent => :destroy
+      has_many :users, :through => :posts
+      belongs_to :user
+    end
+    
+    class Comment
+      include SimplyStored::Couch
+      
+      property :body
+      
+      belongs_to :post
+      belongs_to :user
+    end
+    
+    post = Post.create(:title => 'Look ma!', :body => 'I can have comments')
+    
+    mike = User.create(:login => 'mike')
+    mikes_comment = Comment.create(:user => mike, :post => post, :body => 'Wow, comments are nice')
+    
+    john = User.create(:login => 'john')
+    johns_comment = Comment.create(:user => john, :post => post, :body => 'They are indeed')
+    
+    post.comments
+    # => [mikes_comment, johns_comment]
+    
+    post.comment_count
+    # => 2
+    
+    post.users
+    # => [mike, john]
+
+    post.user_count
+    # => 2
+    
+
+CouchDB - Validations
+=============
+
+Further, you can have validations (using the validatable gem)
+
+    class Project
+      include SimplyStored::Couch
+    
+      property :title
+      property :budget
+      property :deadline, :type => Time
+      property :priority
+      
+      validates_presence_of :budget
+      validates_uniqueness_of :priority
+      validates_format_of :title, :with => /\A[a-z0-9\-']+\Z/, :allow_blank => true
+      validates_inclusion_of :priority, :in => [0,1,2,3,4,5]
+      
+    end
+    
+    project = Project.new
+    project.save
+    # => false
+    
+    project.errors
+    # => #<Validatable::Errors:0x102592740 @errors={:budget=>["can't be empty"], :priority=>["must be one or more of 0, 1, 2, 3, 4, 5"]}
+    
+    project.save!
+    # => raises CouchPotato::Database::ValidationsFailedError: #<CouchPotato::Database::ValidationsFailedError:0x102571130>
+    
+
+CouchDB - S3 Attachments
+=============
+
+Both the CouchDB backend and the SimpleDB backend have support for S3 attachments:
+
+    class Log
+      include SimplyStored::Couch
+      has_s3_attachment :data, :bucket => 'the-bucket-name',
+                               :access_key => 'my-AWS-key-id',
+                               :secret_access_key => 'psst!-secret',
+                               :location => :eu,
+                               :after_delete => :delete
+      
+    end
+    
+    log = Log.new
+    log.data = File.read('/var/log/messages')
+    log.save
+    # => true
+    
+This will create an item on S3 in the specified bucket. The item will use the ID of the log object as the key and the body will be the data attribute. This way you can store big files outside of CouchDB or SimpleDB.    
+    
+
+CouchDB - Soft delete
+=============
+    
+SimplyStored also has support for "soft deleting" - much like acts_as_paranoid. Items will then not be deleted but only marked as deleted. This way you can recover them later.
+
+    class Document
+      include SimplyStored::Couch
+      
+      property :title
+      enable_soft_delete # will use :deleted_at attribute by default
+    end
+    
+    doc = Document.create(:title => 'secret project info')
+    Document.find_all_by_title('secret project info')
+    # => [doc]
+    
+    doc.destroy
+    
+    Document.find_all_by_title('secret project info')
+    # => []
+    
+    Document.find_all_by_title('secret project info', :with_deleted => true)
+    # => [doc]
+
+
+License
+=============
+
+SimplyStored is licensed under the OpenBSD / two-clause BSD license, modeled after the ISC license. See LICENSE.txt
+
+About
+=============
+
+SimplyStored was written by [Mathias Meyer](http://twitter.com/roidrage) and [Jonathan Weiss](http://twitter.com/jweiss) for [Peritor](http://www.peritor.com).
+
+    

data/lib/simply_stored/couch/belongs_to.rb

@@ -15,9 +15,16 @@ module SimplyStored
             }
           }
         eos
+        
+        reduce_definition = <<-eos
+          function(key, values) {
+            return values.length;
+          }
+        eos
          
         view "association_#{self.name.underscore}_belongs_to_#{name}",
           :map => map_definition_without_deleted,
+          :reduce => reduce_definition,
           :type => "custom",
           :include_docs => true
           
@@ -31,6 +38,7 @@ module SimplyStored
          
         view "association_#{self.name.underscore}_belongs_to_#{name}_with_deleted",
           :map => map_definition_with_deleted,
+          :reduce => reduce_definition,
           :type => "custom",
           :include_docs => true
             

data/lib/simply_stored/couch/has_many.rb

@@ -93,6 +93,26 @@ module SimplyStored
         end
       end
       
+      def define_has_many_count(name, through = nil)
+        method_name = name.to_s.singularize.underscore + "_count"
+        define_method(method_name) do |*args|
+          options = args.first && args.first.is_a?(Hash) && args.first
+          if options
+            options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = options[:force_reload]
+            with_deleted = options[:with_deleted]
+          else
+            forced_reload = false
+            with_deleted = false
+          end
+
+          if forced_reload || instance_variable_get("@#{method_name}").nil?
+            instance_variable_set("@#{method_name}", count_associated(through || name, self.class, :with_deleted => with_deleted))
+          end
+          instance_variable_get("@#{method_name}")
+        end
+      end
+      
       class Property
         attr_reader :name, :options
         
@@ -108,6 +128,7 @@ module SimplyStored
           if options[:through]
             owner_clazz.class_eval do
               define_has_many_through_getter(name, options[:through])
+              define_has_many_count(name, options[:through])
             end
           else
             owner_clazz.class_eval do
@@ -115,6 +136,7 @@ module SimplyStored
               define_has_many_setter_add(name)
               define_has_many_setter_remove(name)
               define_has_many_setter_remove_all(name)
+              define_has_many_count(name)
             end
           end
         end

data/lib/simply_stored/couch.rb

@@ -1,3 +1,4 @@
+require 'validatable'
 require 'couch_potato'
 
 require File.expand_path(File.dirname(__FILE__) + '/../simply_stored')

data/lib/simply_stored/instance_methods.rb

@@ -124,11 +124,23 @@ module SimplyStored
       if options[:with_deleted]
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", :key => id))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", :reduce => false, :key => id))
       else
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", :key => id))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", :reduce => false, :key => id))
+      end
+    end
+    
+    def count_associated(from, to, options = {})
+      if options[:with_deleted]
+        CouchPotato.database.view(
+          self.class.get_class_from_name(from).send(
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", :key => id, :reduce => true, :include_docs => false))
+      else
+        CouchPotato.database.view(
+          self.class.get_class_from_name(from).send(
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", :key => id, :reduce => true, :include_docs => false))
       end
     end
     

data/test/simply_stored_couch_test.rb

@@ -627,6 +627,69 @@ class CouchTest < Test::Unit::TestCase
             assert_equal [], user.posts
             assert_equal [], user.instance_variable_get("@posts")
           end
+          
+          context "when counting" do
+            setup do
+              @user = User.create(:title => "Mr.")
+            end
+            
+            should "define a count method" do
+              assert @user.respond_to?(:post_count)
+            end
+            
+            should "cache the result" do
+              assert_equal 0, @user.post_count
+              Post.create(:user => @user)
+              assert_equal 0, @user.post_count
+              assert_equal 0, @user.instance_variable_get("@post_count")
+              @user.instance_variable_set("@post_count", nil)
+              assert_equal 1, @user.post_count
+            end
+            
+            should "force reload even if cached" do
+              assert_equal 0, @user.post_count
+              Post.create(:user => @user)
+              assert_equal 0, @user.post_count
+              assert_equal 1, @user.post_count(:force_reload => true)
+            end
+            
+            should "count the number of belongs_to objects" do
+              assert_equal 0, @user.post_count(:force_reload => true)
+              Post.create(:user => @user)
+              assert_equal 1, @user.post_count(:force_reload => true)
+              Post.create(:user => @user)
+              assert_equal 2, @user.post_count(:force_reload => true)
+            end
+            
+            should "not count foreign objects" do
+              assert_equal 0, @user.post_count
+              Post.create(:user => nil)
+              Post.create(:user => User.create(:title => 'Doc'))
+              assert_equal 0, @user.post_count
+              assert_equal 2, Post.count
+            end
+            
+            should "not count delete objects" do
+              hemorrhoid = Hemorrhoid.create(:user => @user)
+              assert_equal 1, @user.hemorrhoid_count
+              hemorrhoid.delete
+              assert_equal 0, @user.hemorrhoid_count(:force_reload => true)
+              assert_equal 1, @user.hemorrhoid_count(:force_reload => true, :with_deleted => true)
+            end
+            
+            should "work with has_many :through" do
+              assert_equal 0, @user.pain_count
+              first_pain = Pain.create
+              frist_hemorrhoid = Hemorrhoid.create(:user => @user, :pain => first_pain)
+              assert_equal [first_pain], @user.pains
+              assert_equal 1, @user.pain_count(:force_reload => true)
+              
+              second_pain = Pain.create
+              second_hemorrhoid = Hemorrhoid.create(:user => @user, :pain => second_pain)
+              assert_equal 2, @user.pain_count(:force_reload => true)
+            end
+            
+          end
         end
         
         context 'when destroying the parent objects' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simply_stored
 version: !ruby/object:Gem::Version 
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors: 
 - Mathias Meyer, Jonathan Weiss
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-20 00:00:00 +01:00
+date: 2010-02-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,15 +22,29 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.2.15
     version: 
+- !ruby/object:Gem::Dependency 
+  name: validatable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Convenience layer for CouchDB and SimpleDB. Requires CouchPotato and RightAWS library respectively.
 email: info@peritor.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
 files: 
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
 - lib/simply_stored.rb
 - lib/simply_stored/class_methods_base.rb
 - lib/simply_stored/couch.rb