openlogic-couchrest_model 1.0.0

data/lib/couchrest/model/support/couchrest_database.rb

@@ -0,0 +1,13 @@
+#
+# Extend CouchRest's normal database delete! method to ensure any caches are
+# also emptied. Given that this is a rare event, and the consequences are not 
+# very severe, we just completely empty the cache.
+#
+CouchRest::Database.class_eval do
+
+  def delete!
+    Thread.current[:couchrest_design_cache] = { }
+    CouchRest.delete @root
+  end
+
+end

data/lib/couchrest/model/support/couchrest_design.rb

@@ -0,0 +1,33 @@
+
+CouchRest::Design.class_eval do
+
+  # 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!
+    # 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
+
+end

data/lib/couchrest/model/typecast.rb

@@ -0,0 +1,154 @@
+module CouchRest
+  module Model
+    module Typecast
+
+      def typecast_value(value, property) # klass, init_method)
+        return nil if value.nil?
+        klass = property.type_class
+        if value.instance_of?(klass) || klass == Object
+          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
+          property.build(value)
+        end
+      end
+
+      protected
+
+        # Typecast a value to an Integer
+        def typecast_to_integer(value)
+          typecast_to_numeric(value, :to_i)
+        end
+
+        # Typecast a value to a String
+        def typecast_to_string(value)
+          value.to_s
+        end
+
+        # Typecast a value to a true or false
+        def typecast_to_trueclass(value)
+          if value.kind_of?(Integer)
+            return true  if value == 1
+            return false if value == 0
+          elsif value.respond_to?(:to_s)
+            return true  if %w[ true  1 t ].include?(value.to_s.downcase)
+            return false if %w[ false 0 f ].include?(value.to_s.downcase)
+          end
+          value
+        end
+
+        # Typecast a value to a BigDecimal
+        def typecast_to_bigdecimal(value)
+          if value.kind_of?(Integer)
+            value.to_s.to_d
+          else
+            typecast_to_numeric(value, :to_d)
+          end
+        end
+
+        # Typecast a value to a Float
+        def typecast_to_float(value)
+          typecast_to_numeric(value, :to_f)
+        end
+
+        # Match numeric string
+        def typecast_to_numeric(value, method)
+          if value.respond_to?(:to_str)
+            if value.strip.gsub(/,/, '.').gsub(/\.(?!\d*\Z)/, '').to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
+              $1.send(method)
+            else
+              value
+            end
+          elsif value.respond_to?(method)
+            value.send(method)
+          else
+            value
+          end
+        end
+
+        # Typecasts an arbitrary value to a DateTime.
+        # Handles both Hashes and DateTime instances.
+        # This is slow!! Use Time instead.
+        def typecast_to_datetime(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_datetime(value)
+          else
+            DateTime.parse(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Date
+        # Handles both Hashes and Date instances.
+        def typecast_to_date(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_date(value)
+          elsif value.is_a?(Time) # sometimes people think date is time!
+            value.to_date
+          elsif value.to_s =~ /(\d{4})[\-|\/](\d{2})[\-|\/](\d{2})/
+            # Faster than parsing the date
+            Date.new($1.to_i, $2.to_i, $3.to_i)
+          else
+            Date.parse(value)
+          end
+        rescue ArgumentError
+          value
+        end
+
+        # Typecasts an arbitrary value to a Time
+        # Handles both Hashes and Time instances.
+        def typecast_to_time(value)
+          if value.is_a?(Hash)
+            typecast_hash_to_time(value)
+          else
+            Time.parse_iso8601(value.to_s)
+          end
+        rescue ArgumentError
+          value
+        rescue TypeError
+          value
+        end
+
+        # Creates a DateTime instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_datetime(value)
+          DateTime.new(*extract_time(value))
+        end
+
+        # Creates a Date instance from a Hash with keys :year, :month, :day
+        def typecast_hash_to_date(value)
+          Date.new(*extract_time(value)[0, 3])
+        end
+
+        # Creates a Time instance from a Hash with keys :year, :month, :day,
+        # :hour, :min, :sec
+        def typecast_hash_to_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
+          [:year, :month, :day, :hour, :min, :sec].map do |segment|
+            typecast_to_numeric(value.fetch(segment, now.send(segment)), :to_i)
+          end
+        end
+
+        # Typecast a value to a Class
+        def typecast_to_class(value)
+          value.to_s.constantize
+        rescue NameError
+          value
+        end
+
+    end
+  end
+end
+

data/lib/couchrest/model/validations.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require "couchrest/model/validations/casted_model"
+require "couchrest/model/validations/uniqueness"
+
+I18n.load_path << File.join(
+  File.dirname(__FILE__), "validations", "locale", "en.yml"
+)
+
+module CouchRest
+  module Model
+
+    # Validations may be applied to both Model::Base and Model::CastedModel
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+
+      # Determine if the document is valid.
+      #
+      # @example Is the document valid?
+      #   person.valid?
+      #
+      # @example Is the document valid in a context?
+      #   person.valid?(:create)
+      #
+      # @param [ Symbol ] context The optional validation context.
+      #
+      # @return [ true, false ] True if valid, false if not.
+      #
+      def valid?(context = nil)
+        super context ? context : (new? ? :create : :update)
+      end
+
+      module ClassMethods
+
+        # Validates the associated casted model. This method should not be
+        # used within your code as it is automatically included when a CastedModel
+        # is used inside the model.
+        def validates_casted_model(*args)
+          validates_with(CastedModelValidator, _merge_attributes(args))
+        end
+
+        # Validates if the field is unique for this type of document. Automatically creates
+        # a view if one does not already exist and performs a search for all matching
+        # documents.
+        #
+        # Example:
+        #
+        #   class Person < CouchRest::Model::Base
+        #     property :title, String
+        # 
+        #     validates_uniqueness_of :title
+        #   end
+        #
+        # Asside from the standard options, you can specify the name of the view you'd like
+        # to use for the search inside the +:view+ option. The following example would search
+        # for the code in side the +all+ view, useful for when +unique_id+ is used and you'd
+        # like to check before receiving a RestClient Conflict error:
+        #
+        #   validates_uniqueness_of :code, :view => 'all'
+        #
+        # A +:proxy+ parameter is also accepted if you would 
+        # like to call a method on the document on which the view should be performed.
+        #
+        # For Example:
+        #
+        #   # Same as not including proxy:
+        #   validates_uniqueness_of :title, :proxy => 'class'
+        #
+        #   # Person#company.people provides a proxy object for people
+        #   validates_uniqueness_of :title, :proxy => 'company.people'
+        #
+        def validates_uniqueness_of(*args)
+          validates_with(UniquenessValidator, _merge_attributes(args))
+        end
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/validations/casted_model.rb

@@ -0,0 +1,16 @@
+module CouchRest
+  module Model
+    module Validations
+      class CastedModelValidator < ActiveModel::EachValidator
+        
+        def validate_each(document, attribute, value)
+          values = value.is_a?(Array) ? value : [value]
+          return if values.collect {|doc| doc.nil? || doc.valid? }.all?
+          error_options = { :value => value }
+          error_options[:message] = options[:message] if options[:message]
+          document.errors.add(attribute, :invalid, error_options)
+        end
+      end
+    end
+  end
+end

data/lib/couchrest/model/validations/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  errors:
+    messages:
+      taken: "has already been taken"
+

data/lib/couchrest/model/validations/uniqueness.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module CouchRest
+  module Model
+    module Validations
+
+      # Validates if a field is unique 
+      class UniquenessValidator < ActiveModel::EachValidator
+
+        # Ensure we have a class available so we can check for a usable view
+        # or add one if necessary.
+        def setup(model)
+          @model = model
+          if options[:view].blank?
+            attributes.each do |attribute|
+              opts = merge_view_options(attribute)
+
+              if model.respond_to?(:has_view?) && !model.has_view?(opts[:view_name])
+                opts[:keys] << {:allow_nil => true}
+                model.view_by(*opts[:keys])
+              end
+            end
+          end
+        end
+
+        def validate_each(document, attribute, value)
+          opts = merge_view_options(attribute)
+
+          values = opts[:keys].map{|k| document.send(k)}
+          values = values.first if values.length == 1
+
+          model = (document.respond_to?(:model_proxy) && document.model_proxy ? document.model_proxy : @model)
+          # Determine the base of the search
+          base = opts[:proxy].nil? ? model : document.instance_eval(opts[:proxy])
+
+          if base.respond_to?(:has_view?) && !base.has_view?(opts[:view_name])
+            raise "View #{document.class.name}.#{opts[:view_name]} does not exist for validation!"
+          end
+
+          rows = base.view(opts[:view_name], :key => values, :limit => 2, :include_docs => false)['rows']
+          return if rows.empty?
+
+          unless document.new?
+            return if rows.find{|row| row['id'] == document.id}
+          end
+
+          if rows.length > 0
+            opts = options.merge(:value => value)
+            opts.delete(:scope) # Has meaning with I18n!
+            document.errors.add(attribute, :taken, opts)
+          end
+        end
+
+        private
+
+        def merge_view_options(attr)
+          keys = [attr]
+          keys.unshift(*options[:scope]) unless options[:scope].nil?
+
+          view_name = options[:view].nil? ? "by_#{keys.join('_and_')}" : options[:view]
+
+          options.merge({:keys => keys, :view_name => view_name})
+        end
+
+      end
+
+    end
+  end
+end

data/lib/couchrest/model/views.rb

@@ -0,0 +1,151 @@
+module CouchRest
+  module Model
+    module Views
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Define a CouchDB view. The name of the view will be the concatenation
+        # of <tt>by</tt> and the keys joined by <tt>_and_</tt>
+        #  
+        # ==== Example views:
+        #  
+        #   class Post
+        #     # view with default options
+        #     # query with Post.by_date
+        #     view_by :date, :descending => true
+        #  
+        #     # view with compound sort-keys
+        #     # query with Post.by_user_id_and_date
+        #     view_by :user_id, :date
+        #  
+        #     # view with custom map/reduce functions
+        #     # query with Post.by_tags :reduce => true
+        #     view_by :tags,                                                
+        #       :map =>                                                     
+        #         "function(doc) {                                          
+        #           if (doc['model'] == 'Post' && doc.tags) {                   
+        #             doc.tags.forEach(function(tag){                       
+        #               emit(doc.tag, 1);                                   
+        #             });                                                   
+        #           }                                                       
+        #         }",                                                       
+        #       :reduce =>                                                  
+        #         "function(keys, values, rereduce) {                       
+        #           return sum(values);                                     
+        #         }"                                                        
+        #   end
+        #  
+        # <tt>view_by :date</tt> will create a view defined by this Javascript
+        # function:
+        #  
+        #   function(doc) {
+        #     if (doc['model'] == 'Post' && doc.date) {
+        #       emit(doc.date, null);
+        #     }
+        #   }
+        #  
+        # It can be queried by calling <tt>Post.by_date</tt> which accepts all
+        # valid options for CouchRest::Database#view. In addition, calling with
+        # the <tt>:raw => true</tt> option will return the view rows
+        # themselves. By default <tt>Post.by_date</tt> will return the
+        # documents included in the generated view.
+        #  
+        # Calling with :database => [instance of CouchRest::Database] will
+        # send the query to a specific database, otherwise it will go to
+        # the model's default database (use_database)
+        #  
+        # CouchRest::Database#view options can be applied at view definition
+        # time as defaults, and they will be curried and used at view query
+        # time. Or they can be overridden at query time.
+        #  
+        # Custom views can be queried with <tt>:reduce => true</tt> to return
+        # reduce results. The default for custom views is to query with
+        # <tt>:reduce => false</tt>.
+        #  
+        # Views are generated (on a per-model basis) lazily on first-access.
+        # This means that if you are deploying changes to a view, the views for
+        # that model won't be available until generation is complete. This can
+        # take some time with large databases. Strategies are in the works.
+        #  
+        # To understand the capabilities of this view system more completely,
+        # it is recommended that you read the RSpec file at
+        # <tt>spec/couchrest/more/extended_doc_spec.rb</tt>.
+
+        def view_by(*keys)
+          return unless auto_update_design_doc
+
+          opts = keys.pop if keys.last.is_a?(Hash)
+          opts ||= {}
+          ducktype = opts.delete(:ducktype)
+
+          unless ducktype || opts[:map]
+            opts[:guards] ||= []
+            opts[:guards].push "(doc['#{model_type_key}'] == '#{self.to_s}')"
+          end
+          keys.push opts
+          design_doc.view_by(*keys)
+        end
+
+        # returns stored defaults if there is a view named this in the design doc
+        def has_view?(name)
+          design_doc && design_doc.has_view?(name)
+        end
+
+        # Check if the view can be reduced by checking to see if it has a
+        # reduce function.
+        def can_reduce_view?(name)
+          design_doc && design_doc.can_reduce_view?(name)
+        end
+
+        # Dispatches to any named view.
+        def view(name, query={}, &block)
+          query = query.dup # Modifications made on copy!
+          db = query.delete(:database) || database
+          query[:raw] = true if query[:reduce]
+          raw = query.delete(:raw)
+          save_design_doc(db)
+          fetch_view_with_docs(db, name, query, raw, &block)
+        end
+
+        # Find the first entry in the view. If the second parameter is a string
+        # it will be used as the key for the request, for example:
+        #
+        #     Course.first_from_view('by_teacher', 'Fred')
+        #
+        # More advanced requests can be performed by providing a hash:
+        #
+        #     Course.first_from_view('by_teacher', :startkey => 'bbb', :endkey => 'eee')
+        #
+        def first_from_view(name, *args)
+          query = {:limit => 1}
+          case args.first
+          when String, Array
+            query.update(args[1]) unless args[1].nil?
+            query[:key] = args.first
+          when Hash
+            query.update(args.first)
+          end
+          view(name, query).first
+        end
+
+        private
+
+        def fetch_view_with_docs(db, name, opts, raw=false, &block)
+          if raw || (opts.has_key?(:include_docs) && opts[:include_docs] == false)
+            fetch_view(db, name, opts, &block)
+          else
+            opts = opts.merge(:include_docs => true)
+            view = fetch_view db, name, opts, &block
+            view['rows'].collect{|r| build_from_database(r['doc'])} if view['rows']
+          end
+        end
+
+        def fetch_view(db, view_name, opts, &block)
+          raise "A view needs a database to operate on (specify :database option, or use_database in the #{self.class} class)" unless db
+          design_doc.view_on(db, view_name, opts, &block)
+        end
+      end # module ClassMethods
+
+    end
+  end
+end