brianmario-couchrest 0.23

data/lib/couchrest/mixins/class_proxy.rb

@@ -0,0 +1,108 @@
+module CouchRest
+  module Mixins
+    module ClassProxy
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+
+        # Return a proxy object which represents a model class on a
+        # chosen database instance. This allows you to DRY operations
+        # where a database is chosen dynamically.
+        #  
+        # ==== Example:
+        #  
+        #   db = CouchRest::Database.new(...)
+        #   articles = Article.on(db)
+        #
+        #   articles.all { ... }
+        #   articles.by_title { ... }
+        #
+        #   u = articles.get("someid")
+        #
+        #   u = articles.new(:title => "I like plankton")
+        #   u.save    # saved on the correct database
+
+        def on(database)
+          Proxy.new(self, database)
+        end
+      end
+
+      class Proxy #:nodoc:
+        def initialize(klass, database)
+          @klass = klass
+          @database = database
+        end
+        
+        # ExtendedDocument
+        
+        def new(*args)
+          doc = @klass.new(*args)
+          doc.database = @database
+          doc
+        end
+        
+        def method_missing(m, *args, &block)
+          if has_view?(m)
+            query = args.shift || {}
+            view(m, query, *args, &block)
+          else
+            super
+          end
+        end
+        
+        # Mixins::DocumentQueries
+        
+        def all(opts = {}, &block)
+          @klass.all({:database => @database}.merge(opts), &block)
+        end
+        
+        def first(opts = {})
+          @klass.first({:database => @database}.merge(opts))
+        end
+        
+        def get(id)
+          @klass.get(id, @database)
+        end
+        
+        # Mixins::Views
+        
+        def has_view?(view)
+          @klass.has_view?(view)
+        end
+        
+        def view(name, query={}, &block)
+          @klass.view(name, {:database => @database}.merge(query), &block)
+        end
+        
+        def all_design_doc_versions
+          @klass.all_design_doc_versions(@database)
+        end
+        
+        def cleanup_design_docs!
+          @klass.cleanup_design_docs!(@database)
+        end
+        
+        # Mixins::DesignDoc
+        
+        def design_doc
+          @klass.design_doc
+        end
+        
+        def design_doc_fresh
+          @klass.design_doc_fresh
+        end
+        
+        def refresh_design_doc
+          @klass.refresh_design_doc
+        end
+        
+        def save_design_doc
+          @klass.save_design_doc_on(@database)
+        end
+      end
+    end
+  end
+end

data/lib/couchrest/mixins/design_doc.rb

@@ -0,0 +1,90 @@
+require 'digest/md5'
+
+module CouchRest
+  module Mixins
+    module DesignDoc
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        attr_accessor :design_doc, :design_doc_slug_cache, :design_doc_fresh
+        
+        def design_doc
+          @design_doc ||= Design.new(default_design_doc)
+        end
+        
+        def design_doc_id
+          "_design/#{design_doc_slug}"
+        end
+
+        def design_doc_slug
+          return design_doc_slug_cache if (design_doc_slug_cache && design_doc_fresh)
+          funcs = []
+          design_doc['views'].each do |name, view|
+            funcs << "#{name}/#{view['map']}#{view['reduce']}"
+          end
+          md5 = Digest::MD5.hexdigest(funcs.sort.join(''))
+          self.design_doc_slug_cache = "#{self.to_s}-#{md5}"
+        end
+
+        def default_design_doc
+          {
+            "language" => "javascript",
+            "views" => {
+              'all' => {
+                'map' => "function(doc) {
+                  if (doc['couchrest-type'] == '#{self.to_s}') {
+                    emit(null,null);
+                  }
+                }"
+              }
+            }
+          }
+        end
+
+        def refresh_design_doc
+          design_doc['_id'] = design_doc_id
+          design_doc.delete('_rev')
+          #design_doc.database = nil
+          self.design_doc_fresh = true
+        end
+
+        # Save the design doc onto the default database, and update the
+        # design_doc attribute
+        def save_design_doc
+          refresh_design_doc unless design_doc_fresh
+          self.design_doc = update_design_doc(design_doc)
+        end
+
+        # Save the design doc onto a target database in a thread-safe way,
+        # not modifying the model's design_doc
+        def save_design_doc_on(db)
+          update_design_doc(Design.new(design_doc), db)
+        end
+
+        private
+
+        # Writes out a design_doc to a given database, returning the
+        # updated design doc
+        def update_design_doc(design_doc, db = database)
+          saved = db.get(design_doc['_id']) rescue nil
+          if saved
+            design_doc['views'].each do |name, view|
+              saved['views'][name] = view
+            end
+            db.save_doc(saved)
+            saved
+          else
+            design_doc.database = db
+            design_doc.save
+            design_doc
+          end
+        end
+        
+      end # module ClassMethods
+      
+    end
+  end
+end

data/lib/couchrest/mixins/document_queries.rb

@@ -0,0 +1,44 @@
+module CouchRest
+  module Mixins
+    module DocumentQueries
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        
+        # Load all documents that have the "couchrest-type" field equal to the
+        # name of the current class. Take the standard set of
+        # CouchRest::Database#view options.
+        def all(opts = {}, &block)
+          view(:all, opts, &block)
+        end
+
+        # Load the first document that have the "couchrest-type" field equal to
+        # the name of the current class.
+        #
+        # ==== Returns
+        # Object:: The first object instance available
+        # or
+        # Nil:: if no instances available
+        #
+        # ==== Parameters
+        # opts<Hash>::
+        # View options, see <tt>CouchRest::Database#view</tt> options for more info.
+        def first(opts = {})
+          first_instance = self.all(opts.merge!(:limit => 1))
+          first_instance.empty? ? nil : first_instance.first
+        end
+        
+        # Load a document from the database by id
+        def get(id, db = database)
+          doc = db.get id
+          new(doc)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/couchrest/mixins/extended_attachments.rb

@@ -0,0 +1,68 @@
+module CouchRest
+  module Mixins
+    module ExtendedAttachments
+
+      # creates a file attachment to the current doc
+      def create_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return if has_attachment?(args[:name])
+        self['_attachments'] ||= {}
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # reads the data from an attachment
+      def read_attachment(attachment_name)
+        Base64.decode64(database.fetch_attachment(self, attachment_name))
+      end
+
+      # modifies a file attachment on the current doc
+      def update_attachment(args={})
+        raise ArgumentError unless args[:file] && args[:name]
+        return unless has_attachment?(args[:name])
+        delete_attachment(args[:name])
+        set_attachment_attr(args)
+      rescue ArgumentError => e
+        raise ArgumentError, 'You must specify :file and :name'
+      end
+
+      # deletes a file attachment from the current doc
+      def delete_attachment(attachment_name)
+        return unless self['_attachments']
+        self['_attachments'].delete attachment_name
+      end
+
+      # returns true if attachment_name exists
+      def has_attachment?(attachment_name)
+        !!(self['_attachments'] && self['_attachments'][attachment_name] && !self['_attachments'][attachment_name].empty?)
+      end
+
+      # returns URL to fetch the attachment from
+      def attachment_url(attachment_name)
+        return unless has_attachment?(attachment_name)
+        "#{database.root}/#{self.id}/#{attachment_name}"
+      end
+      
+      private
+      
+        def encode_attachment(data)
+          ::Base64.encode64(data).gsub(/\r|\n/,'')
+        end
+
+        def get_mime_type(file)
+          ::MIME::Types.type_for(file.path).empty? ? 
+            'text\/plain' : MIME::Types.type_for(file.path).first.content_type.gsub(/\//,'\/')
+        end
+
+        def set_attachment_attr(args)
+          content_type = args[:content_type] ? args[:content_type] : get_mime_type(args[:file])
+          self['_attachments'][args[:name]] = {
+            'content-type' => content_type,
+            'data'         => encode_attachment(args[:file].read)
+          }
+        end
+      
+    end # module ExtendedAttachments
+  end
+end

data/lib/couchrest/mixins/extended_document_mixins.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), 'properties')
+require File.join(File.dirname(__FILE__), 'document_queries')
+require File.join(File.dirname(__FILE__), 'views')
+require File.join(File.dirname(__FILE__), 'design_doc')
+require File.join(File.dirname(__FILE__), 'validation')
+require File.join(File.dirname(__FILE__), 'extended_attachments')
+require File.join(File.dirname(__FILE__), 'class_proxy')

data/lib/couchrest/mixins/properties.rb

@@ -0,0 +1,129 @@
+require 'time'
+require File.join(File.dirname(__FILE__), '..', 'more', 'property')
+
+module CouchRest
+  module Mixins
+    module Properties
+      
+      class IncludeError < StandardError; end
+      
+      def self.included(base)
+        base.class_eval <<-EOS, __FILE__, __LINE__
+            extlib_inheritable_accessor(:properties) unless self.respond_to?(:properties)
+            self.properties ||= []
+        EOS
+        base.extend(ClassMethods)
+        raise CouchRest::Mixins::Properties::IncludeError, "You can only mixin Properties in a class responding to [] and []=, if you tried to mixin CastedModel, make sure your class inherits from Hash or responds to the proper methods" unless (base.new.respond_to?(:[]) && base.new.respond_to?(:[]=))
+      end
+      
+      def apply_defaults
+        return unless self.respond_to?(:new_document?) && new_document?
+        return unless self.class.respond_to?(:properties) 
+        return if self.class.properties.empty?
+        # TODO: cache the default object
+        self.class.properties.each do |property|
+          key = property.name.to_s
+          # let's make sure we have a default and we can assign the value
+          if property.default && (self.respond_to?("#{key}=") || self.key?(key))
+              if property.default.class == Proc
+                self[key] = property.default.call
+              else
+                self[key] = Marshal.load(Marshal.dump(property.default))
+              end
+            end
+        end
+      end
+      
+      def cast_keys
+        return unless self.class.properties
+        self.class.properties.each do |property|
+          next unless property.casted
+          key = self.has_key?(property.name) ? property.name : property.name.to_sym
+          target = property.type
+          if target.is_a?(Array)
+            next unless self[key]
+            klass = ::CouchRest.constantize(target[0])
+            self[property.name] = self[key].collect do |value|
+              # Auto parse Time objects
+              obj = ( (property.init_method == 'new') && klass == Time) ? Time.parse(value) : klass.send(property.init_method, value)
+              obj.casted_by = self if obj.respond_to?(:casted_by)
+              obj
+            end
+          else
+            # Auto parse Time objects
+            self[property.name] = if ((property.init_method == 'new') && target == 'Time') 
+              self[key].is_a?(String) ? Time.parse(self[key].dup) : self[key]
+            else
+              # Let people use :send as a Time parse arg
+              klass = ::CouchRest.constantize(target)
+              # I'm not convince we should or should not create a new instance if we are casting a doc/extended doc without default value and nothing was passed
+              # unless (property.casted && 
+              #   (klass.superclass == CouchRest::ExtendedDocument || klass.superclass == CouchRest::Document) && 
+              #     (self[key].nil? || property.default.nil?))
+              klass.send(property.init_method, self[key])
+              #end
+            end
+            self[property.name].casted_by = self if self[property.name].respond_to?(:casted_by)
+          end
+        end
+      end
+      
+      module ClassMethods
+        
+        def property(name, options={})
+          existing_property = self.properties.find{|p| p.name == name.to_s}
+          if existing_property.nil? || (existing_property.default != options[:default])
+            define_property(name, options)
+          end
+        end
+        
+        protected
+        
+          # This is not a thread safe operation, if you have to set new properties at runtime
+          # make sure to use a mutex.
+          def define_property(name, options={})
+            # check if this property is going to casted
+            options[:casted] = options[:cast_as] ? options[:cast_as] : false
+            property = CouchRest::Property.new(name, (options.delete(:cast_as) || options.delete(:type)), options)
+            create_property_getter(property) 
+            create_property_setter(property) unless property.read_only == true
+            properties << property
+          end
+          
+          # defines the getter for the property (and optional aliases)
+          def create_property_getter(property)
+            # meth = property.name
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{property.name}
+                self['#{property.name}']
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS, __FILE__, __LINE__
+                alias #{property.alias.to_sym} #{property.name.to_sym}
+              EOS
+            end
+          end
+
+          # defines the setter for the property (and optional aliases)
+          def create_property_setter(property)
+            meth = property.name
+            class_eval <<-EOS
+              def #{meth}=(value)
+                self['#{meth}'] = value
+              end
+            EOS
+
+            if property.alias
+              class_eval <<-EOS
+                alias #{property.alias.to_sym}= #{meth.to_sym}=
+              EOS
+            end
+          end
+          
+      end # module ClassMethods
+      
+    end
+  end
+end