couchrest_model 2.0.0.beta2 → 2.0.0

data/lib/couchrest/model/designs/design.rb

@@ -1,284 +0,0 @@
-
-module CouchRest
-  module Model
-    module Designs
-
-      class Design < ::CouchRest::Design
-
-        # The model Class that this design belongs to and method name
-        attr_accessor :model, :method_name
-
-        # Can this design save itself to the database?
-        # If false, the design will be loaded automatically before a view is executed.
-        attr_accessor :auto_update
-
-
-        # Instantiate a new design document for this model
-        def initialize(model, prefix = nil)
-          self.model       = model
-          self.method_name = self.class.method_name(prefix)
-          suffix = prefix ? "_#{prefix}" : ''
-          self["_id"] = "_design/#{model.to_s}#{suffix}"
-          apply_defaults
-        end
-
-        def sync(db = nil)
-          if auto_update
-            db ||= database
-            if cache_checksum(db) != checksum
-              sync!(db)
-              set_cache_checksum(db, checksum)
-            end
-          end
-          self
-        end
-
-        def sync!(db = nil)
-          db ||= database
-
-          # Load up the last copy. We never blindly overwrite the remote copy
-          # as it may contain views that are not used or known about by
-          # our model.
-          doc = load_from_database(db)
-
-          if !doc || doc['couchrest-hash'] != checksum
-            # We need to save something
-            if doc
-              # Different! Update.
-              doc.merge!(to_hash)
-            else
-              # No previous doc, use a *copy* of our version.
-              # Using a copy prevents reverse updates.
-              doc = to_hash.dup
-            end
-            db.save_doc(doc)
-          end
-
-          self
-        end
-
-        # Migrate the design document preventing downtime on a production
-        # system. Typically this will be used when auto updates are disabled.
-        #
-        # Steps taken are:
-        #
-        #  1. Compare the checksum with the current version
-        #  2. If different, create a new design doc with timestamp
-        #  3. Wait until the view returns a result
-        #  4. Copy over the original design doc
-        #
-        # If a block is provided, it will be called with the result of the migration:
-        #
-        #  * :no_change - Nothing performed as there are no changes.
-        #  * :created   - Add a new design doc as non existed
-        #  * :migrated  - Migrated the existing design doc.
-        #
-        # This can be used for progressivly printing the results of the migration.
-        #
-        # After completion, either a "cleanup" Proc object will be provided to finalize
-        # the process and copy the document into place, or simply nil if no cleanup is
-        # required. For example:
-        #
-        #     print "Synchronising Cat model designs: "
-        #     callback = Cat.design_doc.migrate do |res|
-        #       puts res.to_s
-        #     end
-        #     if callback
-        #       puts "Cleaning up."
-        #       callback.call
-        #     end
-        #
-        def migrate(db = nil, &block)
-          db    ||= database
-          doc     = load_from_database(db)
-          cleanup = nil
-          id      = self['_id']
-
-          if !doc
-            # no need to migrate, just save it
-            new_doc = to_hash.dup
-            db.save_doc(new_doc)
-
-            result = :created
-          elsif doc['couchrest-hash'] != checksum
-            id += "_migration"
-
-            # Delete current migration if there is one
-            old_migration = load_from_database(db, id)
-            db.delete_doc(old_migration) if old_migration
-
-            # Save new design doc
-            new_doc = doc.merge(to_hash)
-            new_doc['_id'] = id
-            new_doc.delete('_rev')
-            db.save_doc(new_doc)
-
-            # Proc definition to copy the migration doc over the original
-            cleanup = Proc.new do
-              db.copy_doc(new_doc, doc)
-              db.delete_doc(new_doc)
-              self
-            end
-
-            result = :migrated
-          else
-            # Already up to date
-            result = :no_change
-          end
-
-          if new_doc && !new_doc['views'].empty?
-            # Create a view query and send
-            name = new_doc['views'].keys.first
-            view = new_doc['views'][name]
-            params = {:limit => 1}
-            params[:reduce] = false if view['reduce']
-            db.view("#{id}/_view/#{name}", params) do |res|
-              # Block to use streamer!
-            end
-          end
-
-          # Provide the result in block
-          yield result if block_given?
-
-          cleanup
-        end
-
-        # Perform a single migration and inmediatly request a cleanup operation:
-        #
-        #     print "Synchronising Cat model designs: "
-        #     Cat.design_doc.migrate! do |res|
-        #       puts res.to_s
-        #     end
-        #
-        def migrate!(db = nil, &block)
-          callback = migrate(db, &block)
-          if callback.is_a?(Proc)
-            callback.call
-          else
-            callback
-          end
-        end
-
-        def checksum
-          sum = self['couchrest-hash']
-          if sum && (@_original_hash == to_hash)
-            sum
-          else
-            checksum!
-          end
-        end
-
-        def database
-          model.database
-        end
-
-        # Override the default #uri method for one that accepts
-        # the current database.
-        # This is used by the caching code.
-        def uri(db = database)
-          "#{db.root}/#{self['_id']}"
-        end
-
-
-        ######## VIEW HANDLING ########
-
-        # Create a new view object.
-        # This overrides the normal CouchRest Design view method
-        def view(name, opts = {})
-          CouchRest::Model::Designs::View.new(self, model, opts, name)
-        end
-
-        # Helper method to provide a list of all the views
-        def view_names
-          self['views'].keys
-        end
-
-        def has_view?(name)
-          view_names.include?(name.to_s)
-        end
-
-        # Add the specified view to the design doc the definition was made in
-        # and create quick access methods in the model.
-        def create_view(name, opts = {})
-          View.define_and_create(self, name, opts)
-        end
-
-        ######## FILTER HANDLING ########
-
-        def create_filter(name, function)
-          filters = (self['filters'] ||= {})
-          filters[name.to_s] = function
-        end
-
-        protected
-
-        def load_from_database(db = database, id = nil)
-          id ||= self['_id']
-          db.get(id)
-        rescue RestClient::ResourceNotFound
-          nil
-        end
-
-        # Calculate and update the checksum of the Design document.
-        # Used for ensuring the latest version has been sent to the database.
-        #
-        # This will generate an flatterned, ordered array of all the elements of the
-        # design document, convert to string then generate an MD5 Hash. This should
-        # result in a consisitent Hash accross all platforms.
-        #
-        def checksum!
-          # Get a deep copy of hash to compare with
-          @_original_hash = Marshal.load(Marshal.dump(to_hash))
-          # create a copy of basic elements
-          base = self.dup
-          base.delete('_id')
-          base.delete('_rev')
-          base.delete('couchrest-hash')
-          result = nil
-          flatten =
-            lambda {|r|
-              (recurse = lambda {|v|
-                if v.is_a?(Hash) || v.is_a?(CouchRest::Document)
-                  v.to_a.map{|v| recurse.call(v)}.flatten
-                elsif v.is_a?(Array)
-                  v.flatten.map{|v| recurse.call(v)}
-                else
-                  v.to_s
-                end
-              }).call(r)
-            }
-          self['couchrest-hash'] = Digest::MD5.hexdigest(flatten.call(base).sort.join(''))
-        end
-
-        def cache
-          Thread.current[:couchrest_design_cache] ||= {}
-        end
-        def cache_checksum(db)
-          cache[uri(db)]
-        end
-        def set_cache_checksum(db, checksum)
-          cache[uri(db)] = checksum
-        end
-
-        def apply_defaults
-          merge!(
-            "language" => "javascript",
-            "views"    => { }
-          )
-        end
-
-
-        class << self
-
-          def method_name(prefix = nil)
-            (prefix ? "#{prefix}_" : '') + 'design_doc'
-          end
-
-        end
-
-      end
-    end
-  end
-end
-
-

data/lib/couchrest/model/migrate.rb

@@ -1,92 +0,0 @@
-module CouchRest
-  module Model
-
-    # Handle CouchDB migrations.
-    #
-    # Actual migrations are handled by the Design document, this serves as a utility
-    # to find all the CouchRest Model submodels and perform the migration on them.
-    #
-    # Also contains some more advanced support for handling proxied models.
-    #
-    # Examples of usage:
-    #
-    #    # Ensure all models have been loaded (only Rails)
-    #    CouchRest::Model::Migrate.load_all_models
-    #
-    #    # Migrate all regular models (not proxied)
-    #    CouchRest::Model::Migrate.all_models
-    #
-    #    # Migrate all models and submodels of proxies
-    #    CouchRest::Model::Migrate.all_models_and_proxies
-    #
-    class Migrate
-
-      def self.all_models
-        callbacks = migrate_each_model(find_models)
-        cleanup(callbacks)
-      end
-
-      def self.all_models_and_proxies
-        callbacks = migrate_each_model(find_models)
-        callbacks += migrate_each_proxying_model(find_proxying_models)
-        cleanup(callbacks)
-      end
-
-      def self.load_all_models
-        # Make a reasonable effort to load all models
-        return unless defined?(Rails)
-        Dir[Rails.root + 'app/models/**/*.rb'].each do |path|
-          require path
-        end
-      end
-
-      def self.find_models
-        CouchRest::Model::Base.subclasses.reject{|m| m.proxy_owner_method.present?}
-      end
-
-      def self.find_proxying_models
-        CouchRest::Model::Base.subclasses.reject{|m| m.proxy_database_method.blank?}
-      end
-
-      def self.migrate_each_model(models, db = nil)
-        callbacks = [ ]
-        models.each do |model|
-          model.design_docs.each do |design|
-            callbacks << migrate_design(model, design, db)
-          end
-        end
-        callbacks
-      end
-
-      def self.migrate_each_proxying_model(models)
-        callbacks = [ ]
-        models.each do |model|
-          submodels = model.proxied_model_names.map{|n| n.constantize}
-          model.all.each do |base|
-            puts "Finding proxied models for #{model}: \"#{base.send(model.proxy_database_method)}\""
-            callbacks += migrate_each_model(submodels, base.proxy_database)
-          end
-        end
-        callbacks
-      end
-
-      def self.migrate_design(model, design, db = nil)
-        print "Migrating #{model.to_s}##{design.method_name}... "
-        callback = design.migrate(db) do |result|
-          puts "#{result.to_s.gsub(/_/, ' ')}"
-        end
-        # Return the callback hash if there is one
-        callback ? {:design => design, :proc => callback, :db => db || model.database} : nil
-      end
-
-      def self.cleanup(methods)
-        methods.compact.each do |cb|
-          name = "/#{cb[:db].name}/#{cb[:design]['_id']}"
-          puts "Activating new design: #{name}"
-          cb[:proc].call
-        end
-      end
-
-    end
-  end
-end