simply_couch 0.1.0

data/lib/simply_couch/model/view/model_view_spec.rb

@@ -0,0 +1,106 @@
+module SimplyCouch
+  module Model
+    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'
+      # and also a results filter (the results will be run through the given proc):
+      #   view :my_view, :key => :name, :results_filter => lambda{|results| results.size}
+      class ModelViewSpec < BaseViewSpec
+        # The key simply_couch uses for class identification in CouchDB documents
+        RUBY_CLASS_KEY = 'ruby_class'
+
+        class JavascriptGenerator
+          def initialize(options, klass)
+            @options = options
+            @klass = klass
+          end
+
+          def map_body(&block)
+            <<-JS
+            function(doc) {
+              if(doc.#{RUBY_CLASS_KEY} && doc.#{RUBY_CLASS_KEY} == '#{@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]
+            _super
+          else
+            {:include_docs => true, :reduce => false}.merge(_super)
+          end
+        end
+
+        def reduce_function
+          "_sum"
+        end
+
+        def process_results(results)
+          processed = if count?
+                        results['rows'].first.try(:[], 'value') || 0
+                      else
+                        results['rows'].map {|row|
+                          row['doc'] || (row['id'] unless view_parameters[:include_docs])
+                        }.compact
+                      end
+          super processed
+        end
+
+        private
+
+        def generator
+          @generator ||= JavascriptGenerator.new(@options, @klass)
+        end
+
+        def count?
+          view_parameters[:reduce]
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/view/properties_view_spec.rb

@@ -0,0 +1,53 @@
+module SimplyCouch
+  module Model
+    module View
+      # A view to return model instances with only some properties populated 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}, #{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
+
+        def language
+          :javascript
+        end
+
+        private
+
+        def properties
+          options[:properties]
+        end
+
+        def properties_for_map(properties)
+          '{' + properties.map{|p| "#{p}: doc.#{p}"}.join(', ') + '}'
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/view/raw_view_spec.rb

@@ -0,0 +1,30 @@
+module SimplyCouch
+  module Model
+    module View
+      # A view for custom map/reduce functions that returns the raw data from couchdb
+      #
+      # 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']}}
+      #
+      # example:
+      #   view :my_custom_view, :map => "function(doc) { emit(doc._id, null); }", :type => :raw, :lib => {:module => "exports.name = 'module';"}
+      class RawViewSpec < BaseViewSpec
+        def map_function
+          options[:map]
+        end
+
+        def reduce_function
+          options[:reduce]
+        end
+
+        def lib
+          options[:lib]
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/view/view_query.rb

@@ -0,0 +1,98 @@
+module SimplyCouch
+  module Model
+    module View
+      # Used to query views (and create them if they don't exist). Usually you won't have to use this class directly.
+      class ViewQuery
+        def initialize(couchrest_database, design_document_name, view, list = nil, lib = 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]
+          @lib = lib
+          @language = language
+          if list
+            @list_function = list.values[0]
+            @list_name = list.keys[0]
+          end
+        end
+
+        def query_view!(parameters = {})
+          update_view unless view_has_been_updated?
+          begin
+            query_view parameters
+          rescue CouchRest::NotFound => e
+            update_view
+            retry
+          end
+        end
+
+        # mainly useful for testing where you drop the database between tests.
+        # only after clearing the cache design docs will be updated/re-created.
+        def self.clear_cache
+          __updated_views.clear
+        end
+
+        def self.__updated_views
+          @updated_views ||= {}
+          @updated_views
+        end
+
+        private
+
+        def update_view
+          design_doc = @database.get "_design/#{@design_document_name}" rescue nil
+          original_views = design_doc && design_doc['views'].dup
+          original_lists = design_doc && design_doc['lists'] && design_doc['lists'].dup
+          view_updated unless design_doc.nil?
+          design_doc ||= empty_design_document
+          design_doc['views'][@view_name.to_s] = view_functions
+          if @lib
+            design_doc['views']['lib'] = (design_doc['views']['lib'] || {}).merge(@lib)
+          end
+          if @list_function
+            design_doc['lists'] ||= {}
+            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}
+          else
+            {'map' => @map_function}
+          end
+        end
+
+        def empty_design_document
+          {'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
+          self.class.__updated_views
+        end
+
+        def query_view(parameters)
+          if @list_name
+            @database.connection.get CouchRest.paramify_url("/#{@database.name}/_design/#{@design_document_name}/_list/#{@list_name}/#{@view_name}", parameters)
+          else
+            @database.view view_url, parameters
+          end
+        end
+
+        def view_url
+          "#{@design_document_name}/#{@view_name}"
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/view.rb

@@ -0,0 +1,8 @@
+require 'simply_couch/model/view/base_view_spec'
+require 'simply_couch/model/view/model_view_spec'
+require 'simply_couch/model/view/properties_view_spec'
+require 'simply_couch/model/view/custom_view_spec'
+require 'simply_couch/model/view/raw_view_spec'
+require 'simply_couch/model/view/view_query'
+require 'simply_couch/model/view/custom_views'
+require 'simply_couch/model/view/lists'

data/lib/simply_couch/model/views/array_property_view_spec.rb

@@ -0,0 +1,26 @@
+module SimplyCouch
+  module Model
+    module Views
+      class ArrayPropertyViewSpec < SimplyCouch::Model::View::ModelViewSpec
+        def map_function
+          "function(doc) {
+             if(doc.ruby_class && doc.ruby_class == '#{@klass.name}') {
+               if (#{formatted_key(key)}.constructor.toString().match(/function Array()/)) {
+                 for (var i in #{formatted_key(key)}) {
+                   emit(#{formatted_key(key)}[i], 1);
+                 }
+               } else {
+                 emit(#{formatted_key(key)}, 1);
+               }
+             }
+           }"
+        end
+
+        def key
+          @options[:key]
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_couch/model/views/deleted_model_view_spec.rb

@@ -0,0 +1,43 @@
+module SimplyCouch
+  module Model
+    module Views
+      class DeletedModelViewSpec < SimplyCouch::Model::View::ModelViewSpec
+        def map_function
+          <<-eos
+            function(doc) {
+              if (doc.ruby_class && doc.ruby_class == '#{@klass.name}') {
+                if (doc['#{@klass.soft_delete_attribute}'] && doc['#{@klass.soft_delete_attribute}'] != null){
+                  // "soft" deleted
+                }else{
+                  emit(doc.created_at, 1);
+                }
+              }
+            }
+          eos
+        end
+
+        def reduce_function
+          '_sum'
+        end
+        
+        def view_parameters
+          _super = super
+          if _super[:reduce]
+            _super
+          else
+            {:include_docs => true, :reduce => false}.merge(_super)
+          end
+        end
+        
+        def process_results(results)
+          if count?
+            results['rows'].first.try(:[], 'value') || 0
+          else
+            results['rows'].map { |row| row['doc'] || row['id'] }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_couch/model/views.rb

@@ -0,0 +1,2 @@
+require 'simply_couch/model/views/array_property_view_spec'
+require 'simply_couch/model/views/deleted_model_view_spec'

data/lib/simply_couch/model.rb

@@ -0,0 +1,195 @@
+require 'active_model'
+
+CouchRest.decode_json_objects = true
+require 'json'
+JSON.create_id = 'ruby_class'
+
+require 'active_support'
+unless {}.respond_to?(:assert_valid_keys)
+  require 'active_support/core_ext'
+end
+I18n.load_path << File.join(File.expand_path(File.dirname(__FILE__)), 'locale', 'en.yml')
+require File.expand_path(File.dirname(__FILE__) + '/../simply_couch')
+require 'simply_couch/model/database'
+require 'simply_couch/model/validations'
+require 'simply_couch/model/pagination_options'
+require 'simply_couch/model/association_property'
+require 'simply_couch/model/properties'
+require 'simply_couch/model/ancestry'
+require 'simply_couch/model/finders'
+require 'simply_couch/model/find_by'
+require 'simply_couch/model/belongs_to'
+require 'simply_couch/model/embedded_in'
+require 'simply_couch/model/has_many'
+require 'simply_couch/model/has_many_embedded'
+require 'simply_couch/model/has_and_belongs_to_many'
+require 'simply_couch/model/has_one'
+require 'simply_couch/model/attachments'
+require 'simply_couch/model/pagination'
+require 'simply_couch/model/persistence'
+require 'simply_couch/model/view'
+require 'simply_couch/model/views'
+require 'simply_couch/include_relation'
+
+module SimplyCouch
+  module Model
+    def self.included(clazz)
+      clazz.send(:include, Persistence)
+      clazz.send(:include, InstanceMethods)
+      clazz.send(:extend, ClassMethods)
+
+      clazz.instance_eval do
+        attr_accessor :_accessible_attributes, :_protected_attributes
+
+        view :all_documents, :key => :created_at
+      end
+    end
+
+    module ClassMethods
+      include SimplyCouch::ClassMethods::Base
+      include SimplyCouch::Model::Database
+      include SimplyCouch::Model::Validations
+      include SimplyCouch::Model::BelongsTo
+      include SimplyCouch::Model::EmbeddedIn
+      include SimplyCouch::Model::HasMany
+      include SimplyCouch::Model::HasManyEmbedded
+      include SimplyCouch::Model::HasAndBelongsToMany
+      include SimplyCouch::Model::HasOne
+      include SimplyCouch::Model::Finders
+      include SimplyCouch::Model::FindBy
+      include SimplyCouch::Model::Pagination
+      include SimplyCouch::Model::PaginationOptions
+      include SimplyCouch::Storage::ClassMethods
+      include SimplyCouch::Model::Ancestry
+
+      def create(attributes = {}, &blk)
+        instance = new(attributes, &blk)
+        instance.save
+        instance
+      end
+
+      def create!(attributes = {}, &blk)
+        instance = new(attributes, &blk)
+        instance.save!
+        instance
+      end
+
+      def enable_soft_delete(property_name = :deleted_at)
+        @_soft_delete_attribute = property_name.to_sym
+        property property_name, :type => Time
+        _define_hard_delete_methods
+        _define_soft_delete_views
+      end
+
+      def soft_delete_attribute
+        @_soft_delete_attribute
+      end
+
+      def soft_deleting_enabled?
+        !soft_delete_attribute.nil?
+      end
+
+      def split_design_documents_per_view(enabled = true)
+        @_split_design_documents = enabled
+      end
+
+      def split_design_documents?
+        @_split_design_documents || false
+      end
+
+      def auto_conflict_resolution_on_save
+        @auto_conflict_resolution_on_save.nil? ? true : @auto_conflict_resolution_on_save
+      end
+
+      def auto_conflict_resolution_on_save=(val)
+        @auto_conflict_resolution_on_save = val
+      end
+
+      def method_missing(name, *args)
+        if name.to_s =~ /^find_by/
+          _define_find_by(name, *args)
+        elsif name.to_s =~ /^find_all_by/
+          _define_find_all_by(name, *args)
+        elsif name.to_s =~ /^count_by/
+          _define_count_by(name, *args)
+        else
+          super
+        end
+      end
+
+      def _define_hard_delete_methods
+        define_method("destroy!") do
+          destroy(true)
+        end
+
+        define_method("delete!") do
+          destroy(true)
+        end
+      end
+
+      def _define_soft_delete_views
+        view :all_documents_without_deleted, :type => SimplyCouch::Model::Views::DeletedModelViewSpec
+      end
+
+      def _define_cache_accessors(name, options)
+        define_method "_get_cached_#{name}" do
+          instance_variable_get("@#{name}") || {}
+        end
+
+        define_method "_set_cached_#{name}" do |value, cache_key|
+          cached = send("_get_cached_#{name}")
+          cached[cache_key] = value
+          instance_variable_set("@#{name}", cached)
+        end
+
+        define_method "_cache_key_for" do |opt|
+          opt.blank? ? :all : opt.to_s
+        end
+      end
+    end
+
+    def extract_association_options(local_options = nil)
+      forced_reload = false
+      with_deleted = false
+      limit = nil
+      descending = false
+      skip = nil
+
+      if local_options
+        local_options.assert_valid_keys(:force_reload, :with_deleted, :limit, :order)
+        forced_reload = local_options.delete(:force_reload)
+        with_deleted = local_options[:with_deleted]
+        limit = local_options[:limit]
+        descending = (local_options[:order] == :desc) ? true : false
+        skip = local_options[:skip]
+      end
+      return [forced_reload, with_deleted, limit, descending, skip]
+    end
+
+    def self.delete_all_design_documents(database)
+      db = CouchRest.database(database)
+      db.info # ensure DB exists
+      design_docs = CouchRest.get("#{database}/_all_docs?startkey=%22_design%22&endkey=%22_design0%22")['rows'].map do |row|
+        [row['id'], row['value']['rev']]
+      end
+      design_docs.each do |doc_id, rev|
+        db.delete_doc({'_id' => doc_id, '_rev' => rev})
+      end
+      design_docs.size
+    end
+
+    def self.compact_all_design_documents(database)
+      db = CouchRest.database(database)
+      db.info # ensure DB exists
+      design_docs = CouchRest.get("#{database}/_all_docs?startkey=%22_design%22&endkey=%22_design0%22")['rows'].map do |row|
+        [row['id'], row['value']['rev']]
+      end
+      design_docs.each do |doc_id, rev|
+        puts "#{database}/_compact/#{doc_id.gsub("_design/",'')}"
+        CouchRest.post("#{database}/_compact/#{doc_id.gsub("_design/",'')}")
+      end
+      design_docs.size
+    end
+
+  end
+end

data/lib/simply_couch/rake.rb

@@ -0,0 +1,23 @@
+namespace :simply_couch do
+  desc "delete all design documents"
+  task :delete_design_documents do
+    require File.dirname(__FILE__) + "/couch"
+    if database = ENV['DATABASE']
+      deleted = SimplyCouch::Model.delete_all_design_documents(database)
+      puts "deleted #{deleted} design documents in #{database}"
+    else
+      puts "please specify which database to clear: DATABASE=http://localhost:5984/simply_couch rake simply_couch:delete_design_documents"
+    end
+  end
+
+  desc "compact all design documents"
+  task :compact_design_documents do
+    require File.dirname(__FILE__) + "/couch"
+    if database = ENV['DATABASE']
+      compacted = SimplyCouch::Model.compact_all_design_documents(database)
+      puts "triggered compaction of #{compacted} design documents in #{database}"
+    else
+      puts "please specify which database to clear: DATABASE=http://localhost:5984/simply_couch rake simply_couch:delete_design_documents"
+    end
+  end
+end