couch_potato-rails2 0.5.6

data/lib/couch_potato/rspec/matchers/list_as_matcher.rb

@@ -0,0 +1,54 @@
+module CouchPotato
+  module RSpec
+    class ListAsProxy
+      def initialize(results_ruby)
+        @results_ruby = results_ruby
+      end
+      
+      def as(expected_ruby)
+        ListAsMatcher.new(expected_ruby, @results_ruby)
+      end
+    end
+    
+    class ListAsMatcher
+      include RunJS
+      
+      def initialize(expected_ruby, results_ruby)
+        @expected_ruby = expected_ruby
+        @results_ruby = results_ruby
+      end
+      
+      def matches?(view_spec)
+        js = <<-JS
+          #{File.read(File.dirname(__FILE__) + '/print_r.js')}
+          #{File.read(File.dirname(__FILE__) + '/json2.js')}
+          var results = #{@results_ruby.to_json};
+          var listed = '';
+          var list = #{view_spec.list_function};
+          
+          var getRow = function() {
+            return results.rows.shift();
+          };
+          var send = function(text) {
+            listed = listed + text;
+          };
+          list();
+          print(print_r(JSON.parse(listed)));
+        JS
+        
+        @actual_ruby = JSON.parse(run_js(js))
+        
+        @expected_ruby == @actual_ruby
+      end
+      
+      def failure_message_for_should
+        "Expected to list as #{@expected_ruby.inspect} but got #{@actual_ruby.inspect}."
+      end
+      
+      def failure_message_for_should_not
+        "Expected to not list as #{@expected_ruby.inspect} but did."
+      end
+      
+    end
+  end
+end

data/lib/couch_potato/rspec/matchers/map_to_matcher.rb

@@ -0,0 +1,49 @@
+require 'json'
+
+
+module CouchPotato
+  module RSpec
+    class MapToProxy
+      def initialize(input_ruby)
+        @input_ruby = input_ruby
+      end
+      
+      def to(*expected_ruby)
+        MapToMatcher.new(expected_ruby, @input_ruby)
+      end
+    end
+    
+    class MapToMatcher
+      include RunJS
+      
+      def initialize(expected_ruby, input_ruby)
+        @expected_ruby = expected_ruby
+        @input_ruby = input_ruby
+      end
+      
+      def matches?(view_spec)
+        js = <<-JS
+          #{File.read(File.dirname(__FILE__) + '/print_r.js')}
+          var doc = #{@input_ruby.to_json};
+          var map = #{view_spec.map_function};
+          var result = [];
+          var emit = function(key, value) {
+            result.push([key, value]);
+          };
+          map(doc);
+          print(print_r(result));
+        JS
+        @actual_ruby = JSON.parse(run_js(js))
+        @expected_ruby == @actual_ruby
+      end
+      
+      def failure_message_for_should
+        "Expected to map to #{@expected_ruby.inspect} but got #{@actual_ruby.inspect}."
+      end
+      
+      def failure_message_for_should_not
+        "Expected not to map to #{@actual_ruby.inspect} but did."
+      end
+    end
+  end
+end

data/lib/couch_potato/rspec/matchers/print_r.js

@@ -0,0 +1,60 @@
+// taken and adapted from http://scriptnode.com/article/javascript-print_r-or-var_dump-equivalent/
+
+/**
+ * Concatenates the values of a variable into an easily readable string
+ * by Matt Hackett [scriptnode.com]
+ * @param {Object} x The variable to debug
+ * @param {Number} max The maximum number of recursions allowed (keep low, around 5 for HTML elements to prevent errors) [default: 10]
+ * @param {String} sep The separator to use between [default: a single space ' ']
+ * @param {Number} l The current level deep (amount of recursion). Do not use this parameter: it's for the function's own use
+ */
+function print_r(x, max, sep, l) {
+
+	l = l || 0;
+	max = max || 10;
+	sep = sep || ' ';
+
+	if (l > max) {
+		throw("Too much recursion");
+	};
+
+	var r = '';
+
+	if (x === null) {
+		r += "null";
+	} else if (is_array(x)) {
+	  r += '[' + x.map(function(i) {
+	    return print_r(i, max, sep, (l + 1));
+	  }).join(', ') + ']';
+	} else if(is_object(x)) {
+    r += '{'
+    var pairs = [];
+    for (i in x) {
+			pairs.push('"' + i + '": ' + print_r(x[i], max, sep, (l + 1)));
+		}
+		r += pairs.join(', ');
+    r += '}';
+	} else if(is_string(x)) {
+	  r += '"' + x + "\"";
+  } else {
+    r += x;
+  };
+
+  return r;
+  
+  function is_string(a) {
+    return typeof a === 'string';
+  };
+	
+	function is_array(a) {
+    return (a &&
+      typeof a === 'object' &&
+      a.constructor === Array);
+  };
+  
+  function is_object(a) {
+    return a && typeof a == 'object'
+  };
+  
+};
+

data/lib/couch_potato/rspec/matchers/reduce_to_matcher.rb

@@ -0,0 +1,50 @@
+module CouchPotato
+  module RSpec
+    class ReduceToProxy
+      def initialize(docs, keys, rereduce = false)
+        @docs, @keys, @rereduce = docs, keys, rereduce
+      end
+      
+      def to(expected_ruby)
+        ReduceToMatcher.new(expected_ruby, @docs, @keys, @rereduce)
+      end
+    end
+    
+    class ReduceToMatcher
+      include RunJS
+      
+      def initialize(expected_ruby, docs, keys, rereduce = false)
+        @expected_ruby, @docs, @keys, @rereduce = expected_ruby, docs, keys, rereduce
+      end
+      
+      def matches?(view_spec)
+        js = <<-JS
+          #{File.read(File.dirname(__FILE__) + '/print_r.js')}
+          
+          sum = function(values) {
+            var rv = 0;
+            for (var i in values) {
+              rv += values[i];
+            }
+            return rv;
+          };
+          
+          var docs = #{@docs.to_json};
+          var keys = #{@keys.to_json};
+          var reduce = #{view_spec.reduce_function};
+          print(print_r({result: reduce(docs, keys, #{@rereduce})}));
+        JS
+        @actual_ruby = JSON.parse(run_js(js))['result']
+        @expected_ruby == @actual_ruby
+      end
+      
+      def failure_message_for_should
+        "Expected to reduce to #{@expected_ruby.inspect} but got #{@actual_ruby.inspect}."
+      end
+      
+      def failure_message_for_should_not
+        "Expected not to reduce to #{@actual_ruby.inspect} but did."
+      end
+    end
+  end
+end

data/lib/couch_potato/rspec/stub_db.rb

@@ -0,0 +1,46 @@
+module CouchPotato::RSpec
+  
+  module StubView
+    class ViewStub
+      def initialize(clazz, view, db)
+        @clazz = clazz
+        @view = view
+        @db = db
+      end
+    
+      def with(*args)
+        @args = args
+        self
+      end
+
+      def and_return(return_value)
+        view_stub = RSpec::Mocks::Mock.new("#{@clazz}.#{@view}(#{@args.try(:join, ', ')}) view")
+        _stub = @clazz.stub(@view)
+        _stub.with(*@args) if @args
+        _stub.and_return(view_stub)
+        @db.stub(:view).with(view_stub).and_return(return_value)
+      end
+    end
+
+    def stub_view(clazz, view)
+      ViewStub.new clazz, view, self
+    end
+  end
+
+  module StubDb
+    def stub_db(options = {})
+      db = stub('db', options)
+      db.extend CouchPotato::RSpec::StubView
+      CouchPotato.stub(:database => db)
+      db
+    end
+  end
+end
+
+module RSpec
+  module Mocks
+    module ExampleMethods
+      include CouchPotato::RSpec::StubDb
+    end
+  end
+end

data/lib/couch_potato/validation.rb

@@ -0,0 +1,16 @@
+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
+    end
+  end
+end

data/lib/couch_potato/validation/with_active_model.rb

@@ -0,0 +1,27 @@
+module CouchPotato
+  module Validation
+    module WithActiveModel
+      def self.included(base)
+        require 'active_model'
+        require 'active_model/translation'
+        base.send :include, ::ActiveModel::Validations
+        base.instance_eval do
+          def before_validation(*names)
+            names.each do |name|
+              validate name
+            end
+          end
+        end
+      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/validation/with_validatable.rb

@@ -0,0 +1,41 @@
+module CouchPotato
+  module Validation
+    module WithValidatable
+      def self.included(base)
+        begin
+          require 'validatable'
+        rescue LoadError
+          puts "Please install the gem validatable using 'gem install validatable'"
+          raise
+        end
+        base.send :include, ::Validatable
+        base.class_eval do
+          # Override the validate method to first run before_validation callback
+          def valid_with_before_validation_callback?
+            errors.clear
+            run_callbacks :validation do
+              before_validation_errors = errors.errors.dup
+              valid_without_before_validation_callback?
+              before_validation_errors.each do |k, v|
+                v.each {|message| errors.add(k, message)}
+              end
+            end
+            errors.empty?
+          end
+          
+          alias_method :valid_without_before_validation_callback?, :valid?
+          alias_method :valid?, :valid_with_before_validation_callback?
+        end
+      end
+    end
+  end
+end
+
+# add [] method to Validatable's implementation of the Errors class
+module Validatable
+  class Errors
+    def [](attribute)
+      [on(attribute)].flatten.compact
+    end
+  end
+end

data/lib/couch_potato/version.rb

@@ -0,0 +1,3 @@
+module CouchPotato
+  VERSION = "0.5.6"
+end

data/lib/couch_potato/view/base_view_spec.rb

@@ -0,0 +1,84 @@
+module CouchPotato
+  module View
+    class BaseViewSpec
+      attr_reader :reduce_function, :list_name, :list_function, :design_document, :view_name, :view_parameters, :klass, :options
+      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]
+        
+        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|
+          @view_parameters[key] = options[key] if options.include?(key)
+        end
+        @view_parameters.merge!(normalized_view_parameters)
+      end
+
+      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
+        else
+          {:key => params}
+        end
+      end
+      
+      def replace_range_key(params)
+        if((key = params[:key]).is_a?(Range))
+          params.delete :key
+          params[:startkey] = key.first
+          params[:endkey] = key.last
+        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')
+        klass_name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        klass_name.tr!("-", "_")
+        doc_name = klass_name.downcase
+
+        if CouchPotato::Config.split_design_documents_per_view
+          doc_name += "_view_#{view_name}"  if view_name.present?
+          doc_name += "_list_#{list_name}" if list_name.present?
+        end
+        doc_name
+      end
+    end
+  end
+end

data/lib/couch_potato/view/custom_view_spec.rb

@@ -0,0 +1,42 @@
+module CouchPotato
+  module View
+    # a view for custom map/reduce functions that still returns model instances
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :include_docs => true, :type => :custom, :reduce => nil
+    class CustomViewSpec < BaseViewSpec
+      def map_function
+        options[:map]
+      end
+      
+      def reduce_function
+        options[:reduce]
+      end
+      
+      def view_parameters
+        {:include_docs => options[:include_docs] || false}.merge(super)
+      end
+      
+      def process_results(results)
+        if count?
+          results['rows'].first.try(:[], 'value') || 0
+        else  
+          results['rows'].map do |row|
+            if row['doc'].instance_of?(klass)
+              row['doc']
+            else
+              klass.json_create row['doc'] || row['value'].merge(:_id => row['id'] || row['key'])
+            end
+          end
+        end
+      end
+      
+      private 
+      
+      def count?
+        view_parameters[:reduce]
+      end
+      
+    end
+  end
+end