couch_potato 0.6.0 → 0.7.0.pre.1

data/lib/couch_potato/rspec/matchers.rb

@@ -1,12 +1,13 @@
+require 'v8'
+
 module CouchPotato
   module RSpec
     module RunJS
       private
-  
+
       def run_js(js)
-        path = 'couch_potato_js_runner.js'
-        File.open(path, 'w') {|f| f << js}
-        `js #{path}`
+        cxt = V8::Context.new
+        cxt.eval(js)
       end
     end
   end
@@ -22,15 +23,15 @@ module RSpec
     def map(document)
       CouchPotato::RSpec::MapToProxy.new(document)
     end
-    
+
     def reduce(docs, keys)
       CouchPotato::RSpec::ReduceToProxy.new(docs, keys)
     end
-    
+
     def rereduce(docs, keys)
       CouchPotato::RSpec::ReduceToProxy.new(docs, keys, true)
     end
-    
+
     def list(results)
       CouchPotato::RSpec::ListAsProxy.new(results)
     end

data/lib/couch_potato/validation.rb

@@ -1,16 +1,20 @@
+require 'active_model'
+require 'active_model/translation'
+
 module CouchPotato
   module Validation
     def self.included(base) #:nodoc:
-      case CouchPotato::Config.validation_framework
-      when :validatable
-        require 'couch_potato/validation/with_validatable'
-        base.send :include, CouchPotato::Validation::WithValidatable
-      when :active_model
-        require 'couch_potato/validation/with_active_model'
-        base.send :include, CouchPotato::Validation::WithActiveModel
-      else
-        raise "Unknown CouchPotato::Config.validation_framework #{CouchPotato::Config.validation_framework.inspect}, options are :validatable or :active_model"
-      end
+      base.send :include, ::ActiveModel::Validations
+      base.send :include, ::ActiveModel::Validations::Callbacks
     end
   end
-end
+end
+
+# provide same interface to errors object as in Validatable
+module ::ActiveModel
+  class Errors
+    def errors
+      self
+    end
+  end
+end

data/lib/couch_potato/version.rb

@@ -1,3 +1,3 @@
 module CouchPotato
-  VERSION = "0.6.0"
+  VERSION = "0.7.0.pre.1"
 end

data/lib/couch_potato/view/base_view_spec.rb

@@ -1,20 +1,22 @@
 module CouchPotato
   module View
     class BaseViewSpec
-      attr_reader :reduce_function, :list_name, :list_function, :design_document, :view_name, :view_parameters, :klass, :options
+      attr_reader :reduce_function, :list_name, :list_function, :design_document, :view_name,
+        :view_parameters, :klass, :options, :language
       private :klass, :options
 
       def initialize(klass, view_name, options, view_parameters)
         normalized_view_parameters = normalize_view_parameters view_parameters
-        
+
         @list_name = normalized_view_parameters.delete(:list) || options[:list]
-        
+        @language = options[:language] || Config.default_language
+
         assert_valid_view_parameters normalized_view_parameters
         @klass = klass
         @design_document = translate_to_design_doc_name(klass.to_s, view_name, @list_name)
         @view_name = view_name
         @options = options
-        
+
         @list_function = klass.lists(@list_name) if @list_name
         @view_parameters = {}
         [:group, :include_docs, :descending, :group_level, :limit].each do |key|
@@ -26,19 +28,19 @@ module CouchPotato
       def process_results(results)
         results
       end
-      
+
       private
-      
+
       def normalize_view_parameters(params)
         normalized_params = params.dup
         hash = wrap_in_hash params
         remove_nil_stale(replace_range_key(hash))
       end
-      
+
       def remove_nil_stale(params)
         params.reject{|name, value| name.to_s == 'stale' && value.nil?}
       end
-      
+
       def wrap_in_hash(params)
         if params.is_a?(Hash)
           params
@@ -46,7 +48,7 @@ module CouchPotato
           {:key => params}
         end
       end
-      
+
       def replace_range_key(params)
         if((key = params[:key]).is_a?(Range))
           params.delete :key
@@ -55,17 +57,17 @@ module CouchPotato
         end
         params
       end
-      
+
       def assert_valid_view_parameters(params)
         params.keys.each do |key|
           raise ArgumentError.new("invalid view parameter: #{key}") unless valid_view_parameters.include?(key.to_s)
         end
       end
-      
+
       def valid_view_parameters
         %w(key keys startkey startkey_docid endkey endkey_docid limit stale descending skip group group_level reduce include_docs inclusive_end)
       end
-      
+
       def translate_to_design_doc_name(klass_name, view_name, list_name)
         klass_name = klass_name.dup
         klass_name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')

data/lib/couch_potato/view/model_view_spec.rb

@@ -5,11 +5,124 @@ module CouchPotato
     #
     # example:
     #   view :my_view, :key => :name
-    # 
+    #
     # in addition you can pass in conditions as a javascript string
     #   view :my_view_only_completed, :key => :name, :conditions => 'doc.completed = true'
     class ModelViewSpec < BaseViewSpec
-      
+      class ErlangGenerator
+        def initialize(options, klass)
+          @options = options
+          @klass = klass
+        end
+
+        def map_function
+          raise NotImplementedError.new("conditions in Erlang not implemented") if @options[:conditions]
+            raise NotImplementedError.new("emit_value in Erlang not implemented") if @options[:emit_value]
+            <<-ERL
+            fun({Doc}) ->
+               case proplists:get_value(<<"#{JSON.create_id}">>, Doc) of
+               <<"#{@klass.name}">> ->
+                 #{formatted_key},
+                 Emit(#{composite_key_brackets emit_key}, 1);
+               _ ->
+                 ok
+               end
+             end.
+            ERL
+        end
+
+        private
+
+        def composite_key_brackets(key)
+          if key.include?(',')
+            "[#{key}]"
+          else
+            key
+          end
+        end
+
+        def formatted_key(_key = nil)
+          _key ||= key
+          if _key.is_a? Array
+            parts = []
+            _key.each_with_index{|k, i|
+              parts << "Key_#{i} = proplists:get_value(<<\"#{k}\">>, Doc, null)"
+            }
+            parts.join(",\n")
+          else
+            "Key = proplists:get_value(<<\"#{_key}\">>, Doc, null)"
+          end
+        end
+
+        def emit_key
+          if key.is_a?(Array)
+            parts = []
+            key.each_with_index{|k, i|
+              parts << "Key_#{i}"
+            }
+            parts.join(', ')
+          else
+            'Key'
+          end
+        end
+
+        def key
+          @options[:key]
+        end
+      end
+
+      class JavascriptGenerator
+        def initialize(options, klass)
+          @options = options
+          @klass = klass
+        end
+
+        def map_body(&block)
+          <<-JS
+          function(doc) {
+            if(doc.#{JSON.create_id} && doc.#{JSON.create_id} == '#{@klass.name}'#{conditions}) {
+              #{yield}
+            }
+          }
+          JS
+        end
+
+        def map_function
+          map_body do
+            "emit(#{formatted_key}, #{emit_value});"
+          end
+        end
+
+        def formatted_key(_key = nil)
+          _key ||= @options[:key]
+          if _key.is_a? Array
+            '[' + _key.map{|key_part| formatted_key(key_part)}.join(', ') + ']'
+          else
+            "doc['#{_key}']"
+          end
+        end
+
+        private
+
+        # Allow custom emit values. Raise when the specified argument is not recognized
+        def emit_value
+          case @options[:emit_value]
+          when Symbol then "doc['#{@options[:emit_value]}']"
+          when String then @options[:emit_value]
+          when Numeric then @options[:emit_value]
+          when NilClass then 1
+          else
+            raise "The emit value specified is not recognized"
+          end
+        end
+
+        def conditions
+          " && (#{@options[:conditions]})" if @options[:conditions]
+        end
+      end
+
+      delegate :map_function, :map_body, :formatted_key, :to => :generator
+
       def view_parameters
         _super = super
         if _super[:reduce]
@@ -18,19 +131,11 @@ module CouchPotato
           {:include_docs => true, :reduce => false}.merge(_super)
         end
       end
-      
-      def map_function
-        map_body do
-          "emit(#{formatted_key(key)}, 1);"
-        end
-      end
-      
+
       def reduce_function
-        "function(key, values) {
-          return sum(values);
-        }"
+        "_sum"
       end
-      
+
       def process_results(results)
         if count?
           results['rows'].first.try(:[], 'value') || 0
@@ -38,38 +143,28 @@ module CouchPotato
           results['rows'].map { |row| row['doc'] || row['id'] }
         end
       end
-      
+
       private
-      
-      def map_body(&block)
-        "function(doc) {
-           if(doc.#{JSON.create_id} && doc.#{JSON.create_id} == '#{@klass.name}'#{conditions_js}) {
-             " + yield + "
-           }
-         }"
-        
-      end
-      
-      def conditions_js
-        " && (#{options[:conditions]})" if options[:conditions]
+
+      def generator
+        case language
+        when :javascript
+          @generator ||= JavascriptGenerator.new(@options, @klass)
+        when :erlang
+          @generator ||= ErlangGenerator.new(@options, @klass)
+        else
+          invalid_language
+        end
       end
-      
+
       def count?
         view_parameters[:reduce]
       end
-      
-      def key
-        options[:key]
-      end
-      
-      def formatted_key(key)
-        if key.is_a? Array
-          '[' + key.map{|attribute| formatted_key(attribute)}.join(', ') + ']'
-        else
-          "doc['#{key}']"
-        end
+
+      def invalid_language
+        raise "unsupported language #{language}"
       end
-      
+
     end
   end
 end

data/lib/couch_potato/view/properties_view_spec.rb

@@ -7,10 +7,10 @@ module CouchPotato
     class PropertiesViewSpec < ModelViewSpec
       def map_function
         map_body do
-          "emit(#{formatted_key(key)}, #{properties_for_map(properties)});"
+          "emit(#{formatted_key}, #{properties_for_map(properties)});"
         end
       end
-      
+
       def reduce_function
         <<-JS
           function(key, values, rereduce) {
@@ -22,23 +22,27 @@ module CouchPotato
           }
         JS
       end
-      
+
       def process_results(results)
         results['rows'].map do |row|
           klass.json_create row['value'].merge(:_id => row['id'])
         end
       end
-      
+
       def view_parameters
         {:include_docs => false}.merge(super)
       end
-      
+
+      def language
+        :javascript
+      end
+
       private
-      
+
       def properties
         options[:properties]
       end
-      
+
       def properties_for_map(properties)
         '{' + properties.map{|p| "#{p}: doc.#{p}"}.join(', ') + '}'
       end

data/lib/couch_potato/view/view_query.rb

@@ -2,12 +2,13 @@ module CouchPotato
   module View
     # Used to query views (and create them if they don't exist). Usually you won't have to use this class directly. Instead it is used internally by the CouchPotato::Database.view method.
     class ViewQuery
-      def initialize(couchrest_database, design_document_name, view, list = nil)
+      def initialize(couchrest_database, design_document_name, view, list = nil, language = :javascript)
         @database = couchrest_database
         @design_document_name = design_document_name
         @view_name = view.keys[0]
         @map_function = view.values[0][:map]
         @reduce_function = view.values[0][:reduce]
+        @language = language
         if list
           @list_function = list.values[0]
           @list_name = list.keys[0]
@@ -35,11 +36,11 @@ module CouchPotato
         design_doc['views'][@view_name.to_s] = view_functions
         if @list_function
           design_doc['lists'] ||= {}
-          design_doc['lists'][@list_name.to_s] = @list_function 
+          design_doc['lists'][@list_name.to_s] = @list_function
         end
         @database.save_doc(design_doc) if original_views != design_doc['views'] || original_lists != design_doc['lists']
       end
-      
+
       def view_functions
         if @reduce_function
           {'map' => @map_function, 'reduce' => @reduce_function}
@@ -47,19 +48,19 @@ module CouchPotato
           {'map' => @map_function}
         end
       end
-      
+
       def empty_design_document
-        {'views' => {}, 'lists' => {}, "_id" => "_design/#{@design_document_name}", "language" => "javascript"}
+        {'views' => {}, 'lists' => {}, "_id" => "_design/#{@design_document_name}", "language" => @language.to_s}
       end
-      
+
       def view_has_been_updated?
         updated_views[[@design_document_name, @view_name]]
       end
-      
+
       def view_updated
         updated_views[[@design_document_name, @view_name]] = true
       end
-      
+
       def updated_views
         @@updated_views ||= {}
         @@updated_views
@@ -79,4 +80,4 @@ module CouchPotato
 
     end
   end
-end
+end

data/lib/couch_potato.rb

@@ -7,9 +7,9 @@ require 'ostruct'
 JSON.create_id = 'ruby_class'
 
 module CouchPotato
-  Config = Struct.new(:database_name, :validation_framework, :split_design_documents_per_view).new
-  Config.validation_framework = :active_model
+  Config = Struct.new(:database_name, :split_design_documents_per_view, :default_language).new
   Config.split_design_documents_per_view = false
+  Config.default_language = :javascript
 
   class NotFound < StandardError; end
 
@@ -29,25 +29,40 @@ module CouchPotato
     @@__couchrest_database ||= CouchRest.database(full_url_to_database)
   end
 
+  # Executes a block of code and yields a datbase with the given name.
+  #
+  # example:
+  #  CouchPotato.with_database('couch_customer') do |couch|
+  #    couch.save @customer
+  #  end
+  #
+  def self.with_database(database_name)
+    @@__databases ||= {}
+    @@__databases["#{database_name}"] = Database.new(couchrest_database_for_name(database_name)) unless @@__databases["#{database_name}"]
+    yield(@@__databases["#{database_name}"])
+  end
+
+  # Creates a CouchRest-Database for directly accessing that functionality.
+  def self.couchrest_database_for_name(database_name)
+    CouchRest.database(full_url_to_database(database_name))
+  end
+
   private
 
-  def self.full_url_to_database
-    raise('No Database configured. Set CouchPotato::Config.database_name') unless CouchPotato::Config.database_name
-    if CouchPotato::Config.database_name.match(%r{https?://})
-      CouchPotato::Config.database_name
+  def self.full_url_to_database(database_name=CouchPotato::Config.database_name)
+    raise('No Database configured. Set CouchPotato::Config.database_name') unless database_name
+    if database_name.match(%r{https?://})
+      database_name
     else
-      "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
+      "http://127.0.0.1:5984/#{database_name}"
     end
   end
 end
 
 $LOAD_PATH << File.dirname(__FILE__)
 
-require 'core_ext/object'
 require 'core_ext/time'
 require 'core_ext/date'
-require 'core_ext/string'
-require 'core_ext/symbol'
 require 'couch_potato/validation'
 require 'couch_potato/persistence'
 require 'couch_potato/railtie' if defined?(Rails)

data/spec/callbacks_spec.rb

@@ -295,3 +295,91 @@ describe "validation callbacks" do
     user.errors[:name].should == []
   end
 end
+
+describe "validation callbacks and filter halt" do
+  class FilterValidationUpdateUser
+    include CouchPotato::Persistence
+
+    property :name
+    before_validation :check_name
+    before_validation_on_update :return_false_from_callback
+
+    def check_name
+      errors.add(:name, 'should be Paul') unless name == "Paul"
+    end
+
+    def return_false_from_callback
+      false
+    end
+  end
+
+  class FilterValidationCreateUser
+    include CouchPotato::Persistence
+
+    property :name
+    before_validation :check_name
+    before_validation_on_save :return_false_from_callback
+    before_validation_on_create :return_false_from_callback
+
+    def check_name
+      errors.add(:name, 'should be Paul') unless name == "Paul"
+    end
+
+    def return_false_from_callback
+      false
+    end
+  end
+
+  class FilterSaveUpdateUser
+    include CouchPotato::Persistence
+
+    property :name
+    before_update :return_false_from_callback
+
+    def return_false_from_callback
+      false
+    end
+  end
+
+  class FilterSaveCreateUser
+    include CouchPotato::Persistence
+
+    property :name
+    before_save :return_false_from_callback
+    before_create :return_false_from_callback
+
+    def return_false_from_callback
+      false
+    end
+  end
+
+  before(:each) do
+    recreate_db
+    @db = CouchPotato.database
+  end
+
+  it "should keep error messages set in custom before_validation if an update filter returns false" do
+    @user = FilterValidationUpdateUser.new(:name => "Paul")
+    @db.save_document(@user).should == true
+    @user.name = 'Bert'
+    @db.save_document(@user).should == false
+  end
+
+  it "should keep error messages set in custom before_validation if a create filter returns false" do
+    @user = FilterValidationCreateUser.new(:name => "Bert")
+    @db.save_document(@user).should == false
+  end
+
+  it "should return false on saving a document when a before update filter returned false" do
+    @user = FilterSaveUpdateUser.new(:name => "Paul")
+    @db.save_document(@user).should == true
+    @user.name = 'Bert'
+    @db.save_document(@user).should == false
+  end
+
+  it "should return false on saving a document when a before save or before create filter returned false" do
+    @user = FilterSaveCreateUser.new(:name => "Bert")
+    @db.save_document(@user).should == false
+  end
+
+end

data/spec/create_spec.rb

@@ -4,26 +4,27 @@ describe "create" do
   before(:each) do
     recreate_db
   end
+
   describe "succeeds" do
     it "should store the class" do
       @comment = Comment.new :title => 'my_title'
       CouchPotato.database.save_document! @comment
       CouchPotato.couchrest_database.get(@comment.id).send(JSON.create_id).should == 'Comment'
     end
-    
+
     it "should persist a given created_at" do
       @comment = Comment.new :created_at => Time.parse('2010-01-02 12:34:48 +0000'), :title => '-'
       CouchPotato.database.save_document! @comment
       CouchPotato.couchrest_database.get(@comment.id).created_at.should == Time.parse('2010-01-02 12:34:48 +0000')
     end
-    
+
     it "should persist a given updated_at" do
       @comment = Comment.new :updated_at => Time.parse('2010-01-02 12:34:48 +0000'), :title => '-'
       CouchPotato.database.save_document! @comment
       CouchPotato.couchrest_database.get(@comment.id).updated_at.should == Time.parse('2010-01-02 12:34:48 +0000')
     end
   end
-  
+
   describe "fails" do
     it "should not store anything" do
       @comment = Comment.new
@@ -31,5 +32,22 @@ describe "create" do
       CouchPotato.couchrest_database.documents['rows'].should be_empty
     end
   end
-end
 
+  describe "multi-db" do
+    TEST_DBS = ['comment_a', 'comment_b', 'comment_c']
+
+    before(:each) do
+      TEST_DBS.each { |db_name| CouchPotato.couchrest_database_for_name(db_name).recreate! }
+    end
+
+    it "should create documents in multiple dbs" do
+      TEST_DBS.each do |db_name|
+        @comment = Comment.new(:title => 'my_title')
+        CouchPotato.with_database(db_name) do |couch|
+          couch.save_document! @comment
+        end
+        CouchPotato.couchrest_database_for_name(db_name).get(@comment.id).send(JSON.create_id).should == 'Comment'
+      end
+    end
+  end
+end

data/spec/default_property_spec.rb

@@ -5,6 +5,7 @@ class Test
 
   property :test, :default => 'Test value'
   property :complex, :default => [1, 2, 3]
+  property :false_value, :default => false
 end
 
 describe 'default properties' do
@@ -35,4 +36,9 @@ describe 'default properties' do
   it "should not return the default value when the actual value is empty" do
     t = Test.new(:complex => []).complex.should == []
   end
+  
+  it "uses the default value also if the default is false" do
+    t = Test.new
+    t.false_value.should == false
+  end
 end