samflores-couchrest 0.12.3 → 0.12.3.2

data/Rakefile

@@ -46,6 +46,40 @@ task :gemspec do
   end
 end
 
+# desc "Update Github Gemspec"
+# task :gemspec do
+#   skip_fields = %w(new_platform original_platform)
+#   integer_fields = %w(specification_version)
+# 
+#   result = "Gem::Specification.new do |s|\n"
+#   spec.instance_variables.each do |ivar|
+#     value = spec.instance_variable_get(ivar)
+#     name  = ivar.split("@").last
+#     next if skip_fields.include?(name) || value.nil? || value == "" || (value.respond_to?(:empty?) && value.empty?)
+#     if name == "dependencies"
+#       value.each do |d|
+#         dep, *ver = d.to_s.split(" ")
+#         result <<  "  s.add_dependency #{dep.inspect}, [#{ /\(([^\,]*)/ . match(ver.join(" "))[1].inspect}]\n"
+#       end
+#     else        
+#       case value
+#       when Array
+#         value =  name != "files" ? value.inspect : value.inspect.split(",").join(",\n")
+#       when Fixnum
+#         # leave as-is
+#       when String
+#         value = value.to_i if integer_fields.include?(name)
+#         value = value.inspect
+#       else
+#         value = value.to_s.inspect
+#       end
+#       result << "  s.#{name} = #{value}\n"
+#     end
+#   end
+#   result << "end"
+#   File.open(File.join(File.dirname(__FILE__), "#{spec.name}.gemspec"), "w"){|f| f << result}
+# end
+
 desc "Run all specs"
 Spec::Rake::SpecTask.new('spec') do |t|
 	t.spec_files = FileList['spec/**/*_spec.rb']

data/lib/couchrest/monkeypatches.rb

@@ -8,7 +8,7 @@ class Time
 
   def to_json(options = nil)
     u = self.utc
-    %("#{u.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+    %("#{u.strftime("%Y/%m/%d %H:%M:%S.#{u.usec} +0000")}")
   end
 
   # Decodes the JSON time format to a UTC time.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: samflores-couchrest
 version: !ruby/object:Gem::Version 
-  version: 0.12.3
+  version: 0.12.3.2
 platform: ruby
 authors: 
 - J. Chris Anderson
@@ -90,7 +90,6 @@ files:
 - lib/couchrest/core/document.rb
 - lib/couchrest/core/model.rb
 - lib/couchrest/core/server.rb
-- lib/couchrest/core/validations.rb
 - lib/couchrest/core/view.rb
 - lib/couchrest/helper
 - lib/couchrest/helper/pager.rb

data/lib/couchrest/core/validations.rb

@@ -1,328 +0,0 @@
-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