samflores-couchrest 0.2.1 → 0.12.3

data/lib/couchrest/core/validations.rb

@@ -0,0 +1,328 @@
+module CouchRest
+
+  class RecordInvalid < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super("Validation failed: #{@self.errors.full_messages.join(", ")}")
+    end
+  end
+
+  class Errors
+    include Enumerable
+
+    def initialize(base) # :nodoc:
+      @base, @errors = base, {}
+    end
+
+    @@default_error_messages = {
+      :inclusion => "is not included in the list",
+      :exclusion => "is reserved",
+      :invalid => "is invalid",
+      :confirmation => "doesn't match confirmation",
+      :accepted  => "must be accepted",
+      :empty => "can't be empty",
+      :blank => "can't be blank",
+      :too_long => "is too long (maximum is %d characters)",
+      :too_short => "is too short (minimum is %d characters)",
+      :wrong_length => "is the wrong length (should be %d characters)",
+      :taken => "has already been taken",
+      :not_a_number => "is not a number",
+      :greater_than => "must be greater than %d",
+      :greater_than_or_equal_to => "must be greater than or equal to %d",
+      :equal_to => "must be equal to %d",
+      :less_than => "must be less than %d",
+      :less_than_or_equal_to => "must be less than or equal to %d",
+      :odd => "must be odd",
+      :even => "must be even",
+      :kind => "must be of kind: %s"
+    }
+
+    cattr_accessor :default_error_messages
+
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    def add(attribute, msg = @@default_error_messages[:invalid])
+      @errors[attribute.to_s] ||= []
+      @errors[attribute.to_s] << msg
+    end
+
+    def add_on_empty(attributes, msg = @@default_error_messages[:empty])
+      for attr in [attributes].flatten
+        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+        is_empty = value.respond_to?("empty?") ? value.empty? : false
+        add(attr, msg) unless !value.nil? && !is_empty
+      end
+    end
+
+    def add_on_blank(attributes, msg = @@default_error_messages[:blank])
+      for attr in [attributes].flatten
+        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+        add(attr, msg) if value.blank?
+      end
+    end
+
+    def invalid?(attribute)
+      !@errors[attribute.to_s].nil?
+    end
+
+    def on(attribute)
+      errors = @errors[attribute.to_s]
+      return nil if errors.nil?
+      errors.size == 1 ? errors.first : errors
+    end
+
+    alias :[] :on
+
+    def on_base
+      on(:base)
+    end
+
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    def each_full
+      full_messages.each { |msg| yield msg }
+    end
+
+    def full_messages
+      full_messages = []
+
+      @errors.each_key do |attr|
+        @errors[attr].each do |msg|
+          next if msg.nil?
+
+          if attr == "base"
+            full_messages << msg
+          else
+            full_messages << @base.class.human_attribute_name(attr) + " " + msg
+          end
+        end
+      end
+      full_messages
+    end
+
+    def empty?
+      @errors.empty?
+    end
+
+    def clear
+      @errors = {}
+    end
+
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+
+    def to_xml(options={})
+      options[:root] ||= "errors"
+      options[:indent] ||= 2
+      options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+      options[:builder].instruct! unless options.delete(:skip_instruct)
+      options[:builder].errors do |e|
+        full_messages.each { |msg| e.error(msg) }
+      end
+    end
+  end
+
+  module Validations
+    VALIDATIONS = %w( validate validate_on_create validate_on_update )
+
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
+      base.class_eval do
+        alias_method_chain :save, :validation
+        # alias_method_chain :save!, :validation
+        # alias_method_chain :update_attributes, :validation_skipping
+      end
+
+      base.send :include, ActiveSupport::Callbacks
+      base.define_callbacks *VALIDATIONS
+    end
+
+    module ClassMethods
+      DEFAULT_VALIDATION_OPTIONS = {
+        :on => :save,
+        :allow_nil => false,
+        :allow_blank => false,
+        :message => nil
+      }.freeze
+
+      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
+      ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
+                                  :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
+                                  :odd => 'odd?', :even => 'even?' }.freeze
+
+      def validates_each(*attrs)
+        options = attrs.extract_options!.symbolize_keys
+        attrs   = attrs.flatten
+
+        send(validation_method(options[:on] || :save), options) do |record|
+          attrs.each do |attr|
+            value = record.send(attr)
+            next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+            yield record, attr, value
+          end
+        end
+      end
+
+      def validates_presence_of(*attr_names)
+        configuration = { :message => CouchRest::Errors.default_error_messages[:blank], :on => :save }
+        configuration.update(attr_names.extract_options!)
+
+        send(validation_method(configuration[:on]), configuration) do |record|
+          record.errors.add_on_blank(attr_names, configuration[:message])
+        end
+      end
+
+      def validates_format_of(*attr_names)
+        configuration = { :message => CouchRest::Errors.default_error_messages[:invalid], :on => :save, :with => nil }
+        configuration.update(attr_names.extract_options!)
+
+        raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash") unless configuration[:with].is_a?(Regexp)
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message] % value) unless value.to_s =~ configuration[:with]
+        end
+      end
+      
+      def validates_kind_of(*attr_names)
+        configuration = { :message => CouchRest::Errors.default_error_messages[:kind], :on => :save, :is => nil, :allow_nil => true }
+        configuration.update(attr_names.extract_options!)
+
+        raise(ArgumentError, "A class must be supplied as the :as option of the configuration hash") unless configuration[:is].is_a?(Class)
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message] % configuration[:is]) unless value.class == configuration[:is]
+        end
+      end
+      
+      def validates_numericality_of(*attr_names)
+        configuration = { :message => CouchRest::Errors.default_error_messages[:not_a_number], :only_integer => false, :allow_nil => false, :on => :save }
+        configuration.update(attr_names.extract_options!)
+        
+        numericality_options = ALL_NUMERICALITY_CHECKS.keys & configuration.keys
+        
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          next if value.nil? and configuration[:allow_nil]
+          if configuration[:only_integer]
+            unless value.to_s =~ /\A[+-]?\d+\Z/
+              record.errors.add(attr_name, configuration[:message] % value)
+              next
+            end
+          else
+            begin
+              Kernel.Float(value)
+            rescue ArgumentError, TypeError
+              record.errors.add(attr_name, configuration[:message] % value)
+              next
+            end
+          end
+          
+          numericality_options.each do |option|
+            case option
+              when :odd, :even
+                record.errors.add(attr_name, CouchRest::Errors.default_error_messages[option] % value) unless value.send(ALL_NUMERICALITY_CHECKS[option])
+              else
+                
+                record.errors.add(attr_name, CouchRest::Errors.default_error_messages[option] % configuration[option]) unless value.send(ALL_NUMERICALITY_CHECKS[option], configuration[option])
+            end
+          end
+        end
+      end
+      
+      def validates_inclusion_of(*attr_names)
+        configuration = { :message => CouchRest::Errors.default_error_messages[:inclusion], :on => :save }
+        configuration.update(attr_name.extract_options!)
+        
+        enum = configuration[:in] || configuration[:within]
+        
+        raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?(:include?)
+        
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) if enum.include?(value)
+        end
+      end
+
+      def create!(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes)
+          yield(object) if block_given?
+          object.save!
+          object
+        end
+      end
+
+      private
+        def validation_method(on)
+          case on
+            when :save   then :validate
+            when :create then :validate_on_create
+            when :update then :validate_on_update
+          end
+        end
+    end
+
+    def save_with_validation(perform_validation = true)
+      if perform_validation && valid? || !perform_validation
+        save_without_validation
+      else
+        false
+      end
+    end
+
+    def save_with_validation!
+      if valid?
+        save_without_validation!
+      else
+        raise RecordInvalid.new(self)
+      end
+    end
+
+    def update_attribute_with_validation_skipping(name, value)
+      send(name.to_s + '=', value)
+      save(false)
+    end
+
+    def valid?
+      errors.clear
+
+      run_callbacks(:validate)
+      validate
+
+      if new_record?
+        run_callbacks(:validate_on_create)
+        validate_on_create
+      else
+        run_callbacks(:validate_on_update)
+        validate_on_update
+      end
+
+      errors.empty?
+    end
+
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+    protected
+
+      def validate #:doc:
+      end
+
+      def validate_on_create #:doc:
+      end
+
+      def validate_on_update # :doc:
+      end
+  end
+end

data/lib/couchrest/monkeypatches.rb

@@ -1,6 +1,3 @@
-require File.join(File.dirname(__FILE__), 'support', 'class')
-require File.join(File.dirname(__FILE__), 'support', 'blank')
-
 # This file must be loaded after the JSON gem and any other library that beats up the Time class.
 class Time
   # This date format sorts lexicographically
@@ -24,96 +21,4 @@ class Time
   # rescue
   #   fallback
   # end
-end
-
-# Monkey patch for faster net/http io
-if RUBY_VERSION.to_f < 1.9
-  class Net::BufferedIO #:nodoc:
-    alias :old_rbuf_fill :rbuf_fill
-    def rbuf_fill
-      if @io.respond_to?(:read_nonblock)
-        begin
-          @rbuf << @io.read_nonblock(65536)
-        rescue Errno::EWOULDBLOCK
-          if IO.select([@io], nil, nil, @read_timeout)
-            retry
-          else
-            raise Timeout::TimeoutError
-          end
-        end
-      else
-        timeout(@read_timeout) do
-          @rbuf << @io.sysread(65536)
-        end
-      end
-    end
-  end
-end
-
-module RestClient
-  def self.copy(url, headers={})
-    Request.execute(:method => :copy,
-      :url => url,
-      :headers => headers)
-  end
-  
-  def self.move(url, headers={})
-    Request.execute(:method => :move,
-    :url => url,
-    :headers => headers)
-  end
-
-#   class Request
-#     
-#     def establish_connection(uri)
-#       Thread.current[:connection].finish if (Thread.current[:connection] && Thread.current[:connection].started?)
-#       p net_http_class
-#       net = net_http_class.new(uri.host, uri.port)
-#       net.use_ssl = uri.is_a?(URI::HTTPS)
-#       net.verify_mode = OpenSSL::SSL::VERIFY_NONE
-#       Thread.current[:connection] = net
-#       Thread.current[:connection].start
-#       Thread.current[:connection]
-#     end
-#     
-#     def transmit(uri, req, payload)
-#       setup_credentials(req)
-#       
-#       Thread.current[:host] ||= uri.host
-#       Thread.current[:port] ||= uri.port
-#       
-#       if (Thread.current[:connection].nil? || (Thread.current[:host] != uri.host))
-#         p "establishing a connection"
-#         establish_connection(uri)
-#       end
-# 
-#       display_log request_log
-#       http = Thread.current[:connection]
-#       http.read_timeout = @timeout if @timeout
-#       
-#       begin
-#         res = http.request(req, payload)
-#       rescue
-#         p "Net::HTTP connection failed, reconnecting"
-#         establish_connection(uri)
-#         http = Thread.current[:connection]
-#         require 'ruby-debug'
-#         debugger
-#         req.body_stream = nil
-#         
-#         res = http.request(req, payload)
-#         display_log response_log(res)
-#         result res
-#       else
-#         display_log response_log(res)
-#         process_result res
-#       end
-#       
-#     rescue EOFError
-#       raise RestClient::ServerBrokeConnection
-#     rescue Timeout::Error
-#       raise RestClient::RequestTimeout
-#     end
-#   end
-  
 end

data/lib/couchrest.rb

@@ -13,61 +13,38 @@
 #    limitations under the License.
 
 require "rubygems"
-gem 'json'
 require 'json'
-gem 'rest-client'
 require 'rest_client'
+require File.expand_path(File.dirname(__FILE__)) + '/couchrest/core/validations'
+
+# require 'extlib'
 
 $:.unshift File.dirname(__FILE__) unless
   $:.include?(File.dirname(__FILE__)) ||
   $:.include?(File.expand_path(File.dirname(__FILE__)))
   
-$COUCHREST_DEBUG ||= false
   
 require 'couchrest/monkeypatches'
 
 # = CouchDB, close to the metal
 module CouchRest
-  VERSION    = '0.2.1' unless self.const_defined?("VERSION")
+  VERSION = '0.12.2'
   
   autoload :Server,       'couchrest/core/server'
   autoload :Database,     'couchrest/core/database'
-  autoload :Response,     'couchrest/core/response'
   autoload :Document,     'couchrest/core/document'
-  autoload :Design,       'couchrest/core/design'
+  autoload :Design,     'couchrest/core/design'
   autoload :View,         'couchrest/core/view'
   autoload :Model,        'couchrest/core/model'
   autoload :Pager,        'couchrest/helper/pager'
   autoload :FileManager,  'couchrest/helper/file_manager'
   autoload :Streamer,     'couchrest/helper/streamer'
   
-  autoload :ExtendedDocument,     'couchrest/more/extended_document'
-  autoload :CastedModel,          'couchrest/more/casted_model'
-  
-  require File.join(File.dirname(__FILE__), 'couchrest', 'mixins')
-  
   # The CouchRest module methods handle the basic JSON serialization 
   # and deserialization, as well as query parameters. The module also includes
   # some helpers for tasks like instantiating a new Database or Server instance.
   class << self
 
-    # extracted from Extlib
-    #
-    # Constantize tries to find a declared constant with the name specified
-    # in the string. It raises a NameError when the name is not in CamelCase
-    # or is not initialized.
-    #
-    # @example
-    # "Module".constantize #=> Module
-    # "Class".constantize #=> Class
-    def constantize(camel_cased_word)
-      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-      end
-
-      Object.module_eval("::#{$1}", __FILE__, __LINE__)
-    end
-    
     # todo, make this parse the url and instantiate a Server or Database instance
     # depending on the specificity.
     def new(*opts)
@@ -125,42 +102,18 @@ module CouchRest
       cr.database(parsed[:database])
     end
     
-    def put(uri, doc = nil)
+    def put uri, doc = nil
       payload = doc.to_json if doc
-      begin
-        JSON.parse(RestClient.put(uri, payload))
-      rescue Exception => e
-        if $COUCHREST_DEBUG == true
-          raise "Error while sending a PUT request #{uri}\npayload: #{payload.inspect}\n#{e}"
-        else
-          raise e
-        end
-      end
+      JSON.parse(RestClient.put(uri, payload))
     end
 
-    def get(uri)
-      begin
-        JSON.parse(RestClient.get(uri), :max_nesting => false)
-      rescue => e
-        if $COUCHREST_DEBUG == true
-          raise "Error while sending a GET request #{uri}\n: #{e}"
-        else
-          raise e
-        end
-      end
+    def get uri
+      JSON.parse(RestClient.get(uri), :max_nesting => false)
     end
   
     def post uri, doc = nil
       payload = doc.to_json if doc
-      begin
-        JSON.parse(RestClient.post(uri, payload))
-      rescue Exception => e
-        if $COUCHREST_DEBUG == true
-          raise "Error while sending a POST request #{uri}\npayload: #{payload.inspect}\n#{e}"
-        else
-          raise e
-        end
-      end
+      JSON.parse(RestClient.post(uri, payload))
     end
   
     def delete uri