couchrest_model 1.1.0.beta → 1.1.0.beta2

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    couchrest_model (1.1.0.beta)
+    couchrest_model (1.1.0.beta2)
       activemodel (~> 3.0.0)
-      couchrest (~> 1.0.2)
+      couchrest (= 1.1.0.pre2)
       mime-types (~> 1.15)
       railties (~> 3.0.0)
       tzinfo (~> 0.3.22)
@@ -12,9 +12,9 @@ GEM
   remote: http://rubygems.org/
   specs:
     abstract (1.0.0)
-    actionpack (3.0.4)
-      activemodel (= 3.0.4)
-      activesupport (= 3.0.4)
+    actionpack (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
       builder (~> 2.1.2)
       erubis (~> 2.6.6)
       i18n (~> 0.4)
@@ -22,13 +22,13 @@ GEM
       rack-mount (~> 0.6.13)
       rack-test (~> 0.5.7)
       tzinfo (~> 0.3.23)
-    activemodel (3.0.4)
-      activesupport (= 3.0.4)
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
       builder (~> 2.1.2)
       i18n (~> 0.4)
-    activesupport (3.0.4)
+    activesupport (3.0.5)
     builder (2.1.2)
-    couchrest (1.0.2)
+    couchrest (1.1.0.pre2)
       json (~> 1.5.1)
       mime-types (~> 1.15)
       rest-client (~> 1.6.1)
@@ -39,13 +39,13 @@ GEM
     json (1.5.1)
     mime-types (1.16)
     rack (1.2.1)
-    rack-mount (0.6.13)
+    rack-mount (0.6.14)
       rack (>= 1.0.0)
     rack-test (0.5.7)
       rack (>= 1.0)
-    railties (3.0.4)
-      actionpack (= 3.0.4)
-      activesupport (= 3.0.4)
+    railties (3.0.5)
+      actionpack (= 3.0.5)
+      activesupport (= 3.0.5)
       rake (>= 0.8.7)
       thor (~> 0.14.4)
     rake (0.8.7)
@@ -60,14 +60,14 @@ GEM
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.3.0)
     thor (0.14.6)
-    tzinfo (0.3.24)
+    tzinfo (0.3.26)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   activemodel (~> 3.0.0)
-  couchrest (~> 1.0.2)
+  couchrest (= 1.1.0.pre2)
   couchrest_model!
   mime-types (~> 1.15)
   rack-test (>= 0.5.7)

data/README.md

@@ -499,6 +499,48 @@ A really interesting use of `:proxy` and `:view` together could be where you'd l
 
 Pretty cool!
 
+## Proxy Support
+
+CouchDB makes it really easy to create databases on the fly, so easy in fact that it is perfectly
+feasable to have one database per user or per company or per whatever makes sense to split into
+its own individual database. CouchRest Model now makes it really easy to support this scenario
+using the proxy methods. Here's a quick example:
+
+    # Define a master company class, its children should be in their own DB
+    class Company < CouchRest::Model::Base
+      use_database COUCHDB_DATABASE
+      property :name
+      property :slug
+
+      proxy_for :invoices
+
+      def proxy_database
+        @proxy_database ||= COUCHDB_SERVER.database!("project_#{slug}")
+      end
+    end
+
+    # Invoices belong to a company
+    class Invoice < CouchRest::Model::Base
+      property :date
+      property :total
+
+      proxied_by :company
+
+      design do
+        view :by_date
+      end
+    end
+
+By setting up our models like this, the invoices should be accessed via a company object:
+
+    company = Company.first
+    company.invoices.new            # build a new invoice
+    company.invoices.by_date.first  # find company's first invoice by date
+
+Internally, all requests for invoices are passed through a model proxy. Aside from the 
+basic methods and views, it also ensures that some of the more complex queries are supported
+such as validating for uniqueness and associations.
+
 
 ## Configuration
 

data/VERSION

@@ -1 +1 @@
-1.1.0.beta
+1.1.0.beta2

data/couchrest_model.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency(%q<couchrest>, "~> 1.0.2")
+  s.add_dependency(%q<couchrest>, "1.1.0.pre2")
   s.add_dependency(%q<mime-types>, "~> 1.15")
   s.add_dependency(%q<activemodel>, "~> 3.0.0")
   s.add_dependency(%q<tzinfo>, "~> 0.3.22")

data/history.txt

@@ -1,3 +1,12 @@
+== 1.1.0.beta2
+
+* Minor enhancements:
+  * Time handling improved in accordance with CouchRest 1.1.0. Always set to UTC.
+  * Refinements to associations and uniqueness validation for proxy (based on issue found by Gleb Kanterov)
+  * Added :allow_nil and :allow_blank options when creating a new view
+  * Unique Validation now supports scopes!
+  * Added support for #keys with list on Design View.
+
 == 1.1.0.beta
 
 * Epic enhancements:

data/lib/couchrest/model/associations.rb

@@ -11,30 +11,37 @@ module CouchRest
       module ClassMethods
 
         # Define an association that this object belongs to.
-        # 
+        #
+        # An attribute will be created matching the name of the attribute
+        # with '_id' on the end, or the foreign key (:foreign_key) provided.
+        #
+        # Searching for the assocated object is performed using a string 
+        # (:proxy) to be evaulated in the context of the owner. Typically
+        # this will be set to the class name (:class_name), or determined
+        # automatically if the owner belongs to a proxy object.
+        #
+        # If the association owner is proxied by another model, than an attempt will
+        # be made to automatically determine the correct place to request
+        # the documents. Typically, this is a method with the pluralized name of the 
+        # association inside owner's owner, or proxy.
+        #
+        # For example, imagine a company acts as a proxy for invoices and clients.
+        # If an invoice belongs to a client, the invoice will need to access the
+        # list of clients via the proxy. So a request to search for the associated
+        # client from an invoice would look like:
+        #
+        #    self.company.clients
+        #
+        # If the name of the collection proxy is not the pluralized assocation name, 
+        # it can be set with the :proxy_name option.
+        #
         def belongs_to(attrib, *options)
-          opts = {
-            :foreign_key => attrib.to_s + '_id',
-            :class_name => attrib.to_s.camelcase,
-            :proxy => nil
-          }
-          case options.first
-          when Hash
-            opts.merge!(options.first)
-          end
+          opts = merge_belongs_to_association_options(attrib, options.first)
 
-          begin
-            opts[:class] = opts[:class_name].constantize
-          rescue NameError
-            raise NameError, "Unable to convert class name into Constant for #{self.name}##{attrib}"
-          end
+          property(opts[:foreign_key], opts)
 
-          prop = property(opts[:foreign_key], opts)
-
-          create_belongs_to_getter(attrib, prop, opts)
-          create_belongs_to_setter(attrib, prop, opts)
-
-          prop
+          create_belongs_to_getter(attrib, opts)
+          create_belongs_to_setter(attrib, opts)
         end
 
         # Provide access to a collection of objects where the associated
@@ -77,44 +84,50 @@ module CouchRest
         # frequently! Use with prudence.
         #
         def collection_of(attrib, *options)
-          opts = {
-            :foreign_key => attrib.to_s.singularize + '_ids',
-            :class_name => attrib.to_s.singularize.camelcase,
-            :proxy => nil
-          }
-          case options.first
-          when Hash
-            opts.merge!(options.first)
-          end
-          begin
-            opts[:class] = opts[:class_name].constantize
-          rescue
-            raise "Unable to convert class name into Constant for #{self.name}##{attrib}"
-          end
+          opts = merge_belongs_to_association_options(attrib, options.first)
+          opts[:foreign_key] = opts[:foreign_key].pluralize
           opts[:readonly] = true
 
-          prop = property(opts[:foreign_key], [], opts)
+          property(opts[:foreign_key], [], opts)
 
-          create_collection_of_property_setter(attrib, prop, opts)
-          create_collection_of_getter(attrib, prop, opts)
-          create_collection_of_setter(attrib, prop, opts)
-
-          prop
+          create_collection_of_property_setter(attrib, opts)
+          create_collection_of_getter(attrib, opts)
+          create_collection_of_setter(attrib, opts)
         end
 
 
         private
 
-        def create_belongs_to_getter(attrib, property, options)
-          base = options[:proxy] || options[:class_name]
+        def merge_belongs_to_association_options(attrib, options = nil)
+          opts = {
+            :foreign_key => attrib.to_s.singularize + '_id',
+            :class_name => attrib.to_s.singularize.camelcase,
+            :proxy_name => attrib.to_s.pluralize
+          }
+          opts.merge!(options) if options.is_a?(Hash)
+
+          # Generate a string for the proxy method call
+          # Assumes that the proxy_owner_method from "proxyable" is available.
+          if opts[:proxy].to_s.empty?
+            opts[:proxy] = if proxy_owner_method
+              "self.#{proxy_owner_method}.#{opts[:proxy_name]}"
+            else
+              opts[:class_name]
+            end
+          end
+
+          opts
+        end
+
+        def create_belongs_to_getter(attrib, options)
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{attrib}
-              @#{attrib} ||= #{options[:foreign_key]}.nil? ? nil : (model_proxy || #{base}).get(self.#{options[:foreign_key]})
+              @#{attrib} ||= #{options[:foreign_key]}.nil? ? nil : #{options[:proxy]}.get(self.#{options[:foreign_key]})
             end
           EOS
         end
 
-        def create_belongs_to_setter(attrib, property, options)
+        def create_belongs_to_setter(attrib, options)
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{attrib}=(value)
               self.#{options[:foreign_key]} = value.nil? ? nil : value.id
@@ -125,7 +138,7 @@ module CouchRest
 
         ### collection_of support methods
 
-        def create_collection_of_property_setter(attrib, property, options)
+        def create_collection_of_property_setter(attrib, options)
           # ensure CollectionOfProxy is nil, ready to be reloaded on request
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{options[:foreign_key]}=(value)
@@ -135,18 +148,17 @@ module CouchRest
           EOS
         end
 
-        def create_collection_of_getter(attrib, property, options)
-          base = options[:proxy] || options[:class_name]
+        def create_collection_of_getter(attrib, options)
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{attrib}(reload = false)
               return @#{attrib} unless @#{attrib}.nil? or reload
-              ary = self.#{options[:foreign_key]}.collect{|i| (model_proxy || #{base}).get(i)}
+              ary = self.#{options[:foreign_key]}.collect{|i| #{options[:proxy]}.get(i)}
               @#{attrib} = ::CouchRest::CollectionOfProxy.new(ary, self, '#{options[:foreign_key]}')
             end
           EOS
         end
 
-        def create_collection_of_setter(attrib, property, options)
+        def create_collection_of_setter(attrib, options)
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{attrib}=(value)
               @#{attrib} = ::CouchRest::CollectionOfProxy.new(value, self, '#{options[:foreign_key]}')

data/lib/couchrest/model/casted_model.rb

@@ -53,7 +53,7 @@ module CouchRest::Model
     end
     alias :to_key :id
     alias :to_param :id
-    
+
     # Sets the attributes from a hash
     def update_attributes_without_saving(hash)
       hash.each do |k, v|

data/lib/couchrest/model/core_extensions/time_parsing.rb

@@ -0,0 +1,66 @@
+module CouchRest
+  module Model
+    module CoreExtensions
+      module TimeParsing
+
+        if RUBY_VERSION < "1.9.0"
+          # Overrwrite Ruby's standard new method to provide compatible support
+          # of 1.9.2's Time.new method.
+          #
+          # Only supports syntax like:
+          #
+          #   Time.new(2011, 4, 1, 18, 50, 32, "+02:00")
+          #   # or
+          #   Time.new(2011, 4, 1, 18, 50, 32)
+          #
+          def new(*args)
+            return super() if (args.empty?)
+            zone = args.delete_at(6)
+            time = mktime(*args)
+            if zone =~ /([\+|\-]?)(\d{2}):?(\d{2})/
+              tz_difference = ("#{$1 == '-' ? '+' : '-'}#{$2}".to_i * 3600) + ($3.to_i * 60)
+              time + tz_difference + zone_offset(time.zone)
+            else
+              time
+            end
+          end
+        end
+
+        # Attemtps to parse a time string in ISO8601 format.
+        # If no match is found, the standard time parse will be used.
+        #
+        # Times, unless provided with a time zone, are assumed to be in 
+        # UTC.
+        #
+        def parse_iso8601(string)
+          if (string =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})[T|\s](\d{2}):(\d{2}):(\d{2})(Z| ?([\+|\s|\-])?(\d{2}):?(\d{2}))?/)
+            # $1 = year
+            # $2 = month
+            # $3 = day
+            # $4 = hours
+            # $5 = minutes
+            # $6 = seconds
+            # $7 = UTC or Timezone
+            # $8 = time zone direction
+            # $9 = tz difference hours
+            # $10 = tz difference minutes
+
+            if (!$7.to_s.empty? && $7 != 'Z')
+              new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, "#{$8 == '-' ? '-' : '+'}#{$9}:#{$10}")
+            else
+              utc($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
+            end
+          else
+            parse(string)
+          end
+        end
+
+      end
+    end
+  end
+end
+
+Time.class_eval do
+  extend CouchRest::Model::CoreExtensions::TimeParsing
+end
+

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

@@ -25,7 +25,7 @@ module CouchRest
             self.owner    = parent
             self.name     = name.to_s
             # Default options:
-            self.query    = { :reduce => false }
+            self.query    = { }
           elsif parent.is_a?(self.class)
             self.model    = (new_query.delete(:proxy) || parent.model)
             self.owner    = parent.owner
@@ -139,12 +139,6 @@ module CouchRest
           execute['total_rows']
         end
 
-        # Convenience wrapper around the rows result set. This will provide
-        # and array of keys.
-        def keys
-          rows.map{|r| r.key}
-        end
-
         # Convenience wrapper to provide all the values from the route
         # set without having to go through +rows+.
         def values
@@ -181,7 +175,7 @@ module CouchRest
         #
         # Cannot be used when the +#startkey+ or +#endkey+ have been set.
         def key(value)
-          raise "View#key cannot be used when startkey or endkey have been set" unless query[:startkey].nil? && query[:endkey].nil?
+          raise "View#key cannot be used when startkey or endkey have been set" unless query[:keys].nil? && query[:startkey].nil? && query[:endkey].nil?
           update_query(:key => value)
         end
 
@@ -193,7 +187,7 @@ module CouchRest
         #
         # Cannot be used if the key has been set.
         def startkey(value)
-          raise "View#startkey cannot be used when key has been set" unless query[:key].nil?
+          raise "View#startkey cannot be used when key has been set" unless query[:key].nil? && query[:keys].nil?
           update_query(:startkey => value)
         end
 
@@ -210,7 +204,7 @@ module CouchRest
         # See the +#startkey+ method for more details and the +#inclusive_end+
         # option.
         def endkey(value)
-          raise "View#endkey cannot be used when key has been set" unless query[:key].nil?
+          raise "View#endkey cannot be used when key has been set" unless query[:key].nil? && query[:keys].nil?
           update_query(:endkey => value)
         end
 
@@ -221,6 +215,22 @@ module CouchRest
           update_query(:endkey_docid => value.is_a?(String) ? value : value.id)
         end
 
+        # Keys is a special CouchDB option that will cause the view request to be POSTed
+        # including an array of keys. Only documents with the matching keys will be 
+        # returned. This is much faster than sending multiple requests for a set 
+        # non-consecutive documents.
+        #
+        # If no values are provided, this method will act as a wrapper around 
+        # the rows result set, providing an array of keys.
+        def keys(*keys)
+          if keys.empty?
+            rows.map{|r| r.key}
+          else
+            raise "View#keys cannot by used when key or startkey/endkey have been set" unless query[:key].nil? && query[:startkey].nil? && query[:endkey].nil?
+            update_query(:keys => keys.first)
+          end
+        end
+
 
         # The results should be provided in descending order.
         #
@@ -341,8 +351,6 @@ module CouchRest
           (offset_value / limit_value) + 1
         end
 
-
-
         protected
 
         def include_docs!
@@ -371,7 +379,7 @@ module CouchRest
         def use_database
           query[:database] || model.database
         end
-        
+
         def execute
           return self.result if result
           raise "Database must be defined in model or view!" if use_database.nil?
@@ -412,6 +420,16 @@ module CouchRest
           # The view name is the same, but three keys would be used in the
           # subsecuent index.
           #
+          # By default, a check is made on each of the view's keys to ensure they
+          # do not contain a nil value ('null' in javascript). This is probably what
+          # you want in most cases but sometimes in can be useful to create an
+          # index where nil is permited. Set the <tt>:allow_nil</tt> option to true to
+          # remove this check.
+          #
+          # Conversely, keys are not checked to see if they are empty or blank. If you'd
+          # like to enable this, set the <tt>:allow_blank</tt> option to false. The default
+          # is true, empty strings are permited in the indexes.
+          #
           def create(model, name, opts = {})
 
             unless opts[:map]
@@ -421,12 +439,14 @@ module CouchRest
 
               raise "View cannot be created without recognised name, :map or :by options" if opts[:by].nil?
 
+              opts[:allow_blank] = opts[:allow_blank].nil? ? true : opts[:allow_blank]
               opts[:guards] ||= []
               opts[:guards].push "(doc['#{model.model_type_key}'] == '#{model.to_s}')"
 
               keys = opts[:by].map{|o| "doc['#{o}']"}
               emit = keys.length == 1 ? keys.first : "[#{keys.join(', ')}]"
-              opts[:guards] += keys.map{|k| "(#{k} != null)"}
+              opts[:guards] += keys.map{|k| "(#{k} != null)"} unless opts[:allow_nil]
+              opts[:guards] += keys.map{|k| "(#{k} != '')"} unless opts[:allow_blank]
               opts[:map] = <<-EOF
                 function(doc) {
                   if (#{opts[:guards].join(' && ')}) {

data/lib/couchrest/model/properties.rb

@@ -131,8 +131,10 @@ module CouchRest
         end
 
         # Automatically set <tt>updated_at</tt> and <tt>created_at</tt> fields
-        # on the document whenever saving occurs. CouchRest uses a pretty
-        # decent time format by default. See Time#to_json
+        # on the document whenever saving occurs.
+        # 
+        # These properties are casted as Time objects, so they should always
+        # be set to UTC.
         def timestamps!
           class_eval <<-EOS, __FILE__, __LINE__
             property(:updated_at, Time, :read_only => true, :protected => true, :auto_validation => false)

data/lib/couchrest/model/proxyable.rb

@@ -4,31 +4,36 @@ module CouchRest
     module Proxyable
       extend ActiveSupport::Concern
 
-      included do
-        attr_accessor :model_proxy
-      end
-
       module ClassMethods
 
         # Define a collection that will use the base model for the database connection
         # details.
-        def proxy_for(model_name, options = {})
+        def proxy_for(assoc_name, options = {})
           db_method = options[:database_method] || "proxy_database"
-          options[:class_name] ||= model_name.to_s.singularize.camelize
+          options[:class_name] ||= assoc_name.to_s.singularize.camelize
           class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def #{model_name}
+            def #{assoc_name}
               unless respond_to?('#{db_method}')
                 raise "Missing ##{db_method} method for proxy"
               end
-              @#{model_name} ||= CouchRest::Model::Proxyable::ModelProxy.new(::#{options[:class_name]}, self, self.class.to_s.underscore, #{db_method})
+              @#{assoc_name} ||= CouchRest::Model::Proxyable::ModelProxy.new(::#{options[:class_name]}, self, self.class.to_s.underscore, #{db_method})
             end
           EOS
         end
 
         def proxied_by(model_name, options = {})
-          raise "Model can only be proxied once or ##{model_name} already defined" if method_defined?(model_name)
+          raise "Model can only be proxied once or ##{model_name} already defined" if method_defined?(model_name) || !proxy_owner_method.nil?
+          self.proxy_owner_method = model_name
+          attr_accessor :model_proxy
           attr_accessor model_name
         end
+
+        # Define an a class variable accessor ready to be inherited and unique
+        # for each Class using the base.
+        # Perhaps there is a shorter way of writing this.
+        def proxy_owner_method=(name); @proxy_owner_method = name; end
+        def proxy_owner_method; @proxy_owner_method; end
+
       end
 
       class ModelProxy
@@ -132,10 +137,10 @@ module CouchRest
         # Update the document's proxy details, specifically, the fields that
         # link back to the original document.
         def proxy_update(doc)
-          if doc
-            doc.database = @database if doc.respond_to?(:database=)
-            doc.model_proxy = self if doc.respond_to?(:model_proxy=) 
-            doc.send("#{owner_name}=", owner) if doc.respond_to?("#{owner_name}=")
+          if doc && doc.is_a?(model)
+            doc.database = @database
+            doc.model_proxy = self
+            doc.send("#{owner_name}=", owner)
           end
           doc
         end

data/lib/couchrest/model/typecast.rb

@@ -1,26 +1,3 @@
-class Time                       
-  # returns a local time value much faster than Time.parse
-  def self.mktime_with_offset(string)
-    string =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})[T|\s](\d{2}):(\d{2}):(\d{2})(([\+|\s|\-])*(\d{2}):?(\d{2}))?/
-    # $1 = year
-    # $2 = month
-    # $3 = day
-    # $4 = hours
-    # $5 = minutes
-    # $6 = seconds
-    # $8 = time zone direction
-    # $9 = tz difference
-    # utc time with wrong TZ info: 
-    time = mktime($1, RFC2822_MONTH_NAME[$2.to_i - 1], $3, $4, $5, $6)
-    if ($7)
-      tz_difference = ("#{$8 == '-' ? '+' : '-'}#{$9}".to_i * 3600)
-      time + tz_difference + zone_offset(time.zone) 
-    else
-      time
-    end
-  end 
-end
-
 module CouchRest
   module Model
     module Typecast
@@ -29,7 +6,11 @@ module CouchRest
         return nil if value.nil?
         klass = property.type_class
         if value.instance_of?(klass) || klass == Object
-          value
+          if klass == Time && !value.utc?
+            value.utc # Ensure Time is always in UTC
+          else
+            value
+          end
         elsif [String, TrueClass, Integer, Float, BigDecimal, DateTime, Time, Date, Class].include?(klass)
           send('typecast_to_'+klass.to_s.downcase, value)
         else
@@ -127,12 +108,11 @@ module CouchRest
           if value.is_a?(Hash)
             typecast_hash_to_time(value)
           else
-            Time.mktime_with_offset(value.to_s)
+            Time.parse_iso8601(value.to_s)
           end
         rescue ArgumentError
           value
         rescue TypeError
-          # After failures, resort to normal time parse
           value
         end
 
@@ -150,13 +130,13 @@ module CouchRest
         # Creates a Time instance from a Hash with keys :year, :month, :day,
         # :hour, :min, :sec
         def typecast_hash_to_time(value)
-          Time.local(*extract_time(value))
+          Time.utc(*extract_time(value))
         end
 
         # Extracts the given args from the hash. If a value does not exist, it
         # uses the value of Time.now.
         def extract_time(value)
-          now  = Time.now
+          now = Time.now
           [:year, :month, :day, :hour, :min, :sec].map do |segment|
             typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
           end