davber_couch_potato 0.3.0

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/matchers.rb

@@ -0,0 +1,39 @@
+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}`
+      end
+    end
+  end
+end
+
+
+require 'couch_potato/rspec/matchers/map_to_matcher'
+require 'couch_potato/rspec/matchers/reduce_to_matcher'
+require 'couch_potato/rspec/matchers/list_as_matcher'
+
+module Spec
+  module Matchers
+    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
+  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 = Spec::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 Spec
+  module Mocks
+    module ExampleMethods
+      include CouchPotato::RSpec::StubDb
+    end
+  end
+end

data/lib/couch_potato/rspec.rb

@@ -0,0 +1,2 @@
+require 'couch_potato/rspec/stub_db'
+require 'couch_potato/rspec/matchers'

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,37 @@
+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?
+            errors.clear
+            run_callbacks :before_validation
+            before_validation_errors = errors.errors.dup
+            super
+            before_validation_errors.each do |k, v|
+              v.each {|message| errors.add(k, message)}
+            end
+            errors.empty?
+          end
+        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/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/view/base_view_spec.rb

@@ -0,0 +1,67 @@
+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
+        # If there is a specified design name generator, we use that one
+        @design_document = CouchPotato.design_name_fun.call klass
+        @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
+        replace_range_key hash
+      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
+    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

data/lib/couch_potato/view/custom_views.rb

@@ -0,0 +1,52 @@
+require 'couch_potato/view/base_view_spec'
+require 'couch_potato/view/model_view_spec'
+require 'couch_potato/view/properties_view_spec'
+require 'couch_potato/view/custom_view_spec'
+require 'couch_potato/view/raw_view_spec'
+
+
+module CouchPotato
+  module View
+    module CustomViews
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def views(view_name = nil) #:nodoc:
+          if view_name
+            _find_view(view_name)
+          else
+            @views ||= {}
+          end
+        end
+
+        def execute_view(view_name, view_parameters) #:nodoc:
+          view_spec_class(views(view_name)[:type]).new(self, view_name, views(view_name), view_parameters)
+        end
+        
+        # Declare a CouchDB view, for examples on how to use see the *ViewSpec classes in CouchPotato::View
+        def view(view_name, options)
+          view_name = view_name.to_s
+          views[view_name] = options
+          method_str = "def #{view_name}(view_parameters = {}); execute_view(\"#{view_name}\", view_parameters); end"
+          self.instance_eval(method_str)
+        end
+
+        def view_spec_class(type) #:nodoc:
+          if type && type.is_a?(Class)
+            type
+          else
+            name = type.nil? ? 'Model' : type.to_s.camelize
+            CouchPotato::View.const_get("#{name}ViewSpec")
+          end
+        end
+        
+        def _find_view(view) #:nodoc:
+          (@views && @views[view]) || (superclass._find_view(view) if superclass.respond_to?(:_find_view))
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/lists.rb

@@ -0,0 +1,23 @@
+module CouchPotato
+  module View
+    module Lists
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+      
+      module ClassMethods
+        def list(name, function)
+          lists[name] = function
+        end
+        
+        def lists(name = nil)
+          if name.nil?
+            @lists ||= {}
+          else
+            (@lists && @lists[name]) || (superclass.lists(name) if superclass.respond_to?(:lists))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/view/model_view_spec.rb

@@ -0,0 +1,75 @@
+module CouchPotato
+  module View
+    # A view to return model instances by searching its properties.
+    # If you pass reduce => true will count instead
+    #
+    # 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
+      
+      def view_parameters
+        _super = super
+        if _super[:reduce]
+          _super
+        else
+          {: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);
+        }"
+      end
+      
+      def process_results(results)
+        if count?
+          results['rows'].first.try(:[], 'value') || 0
+        else
+          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]
+      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
+      end
+      
+    end
+  end
+end

data/lib/couch_potato/view/properties_view_spec.rb

@@ -0,0 +1,47 @@
+module CouchPotato
+  module View
+    # A view to return model instances with only some properties poulated by searching its properties, e.g. for very large documents where you are only interested in some of their data
+    #
+    # example:
+    #   view :my_view, :key => :name, :properties => [:name, :author], :type => :properties
+    class PropertiesViewSpec < ModelViewSpec
+      def map_function
+        map_body do
+          "emit(#{formatted_key(key)}, #{properties_for_map(properties)});"
+        end
+      end
+      
+      def reduce_function
+        <<-JS
+          function(key, values, rereduce) {
+            if(rereduce) {
+              return sum(values);
+            } else {
+              return values.length;
+            }
+          }
+        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
+      
+      private
+      
+      def properties
+        options[:properties]
+      end
+      
+      def properties_for_map(properties)
+        '{' + properties.map{|p| "#{p}: doc.#{p}"}.join(', ') + '}'
+      end
+    end
+  end
+end

data/lib/couch_potato/view/raw_view_spec.rb

@@ -0,0 +1,25 @@
+module CouchPotato
+  module View
+    # A view for custom map/reduce functions that returns the raw data fromcouchdb
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :reduce => nil
+    # optionally you can pass in a results filter which you can use to process the raw couchdb results before returning them
+    #
+    # example:
+    #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :results_filter => lambda{|results| results['rows].map{|row| row['value']}}
+    class RawViewSpec < BaseViewSpec
+      def map_function
+        options[:map]
+      end
+      
+      def process_results(results)
+        options[:results_filter] ? options[:results_filter].call(results) : results
+      end
+      
+      def reduce_function
+        options[:reduce]
+      end
+    end
+  end
+end