mongoid_ext 0.6.2 → 0.7.1

data/lib/mongoid_ext/paranoia.rb

@@ -86,7 +86,7 @@ module MongoidExt #:nodoc:
           end
 
           def self.compact!(date = 1.month.ago)
-            self.delete_all(:created_at.lte => date)
+            self.delete_all(:created_at => {:$lte => date.to_time})
           end
 
           private

data/lib/mongoid_ext/patches.rb

@@ -14,4 +14,17 @@ module Mongo
       doc['retval']
     end
   end
-end
+end
+
+module Mongoid
+  module Document
+    def self.included(base)
+      models << base.to_s
+      super
+    end
+
+    def self.models
+      @models ||= []
+    end
+  end
+end

data/lib/mongoid_ext/storage.rb

@@ -1,12 +1,10 @@
 module MongoidExt
   module Storage
-    def self.included(model)
-      model.class_eval do
-        extend ClassMethods
+    extend ActiveSupport::Concern
 
-        validate :add_mm_storage_errors
-        file_list :file_list
-      end
+    included do
+      validate :__add_storage_errors
+      file_list :file_list
     end
 
     def put_file(name, io, options = {})
@@ -29,12 +27,12 @@ module MongoidExt
       file_list.files
     end
 
-    def mm_storage_errors
-      @mm_storage_errors ||= {}
+    def storage_errors
+      @storage_errors ||= {}
     end
 
-    def add_mm_storage_errors
-      mm_storage_errors.each do |k, msgs|
+    def __add_storage_errors
+      storage_errors.each do |k, msgs|
         msgs.each do |msg|
           self.errors.add(k, msg)
         end
@@ -53,18 +51,23 @@ module MongoidExt
 
           if list.nil?
             list = self[name] = MongoidExt::FileList.new
-          elsif list.class == BSON::OrderedHash || list.class == Hash
+          elsif list.class == BSON::OrderedHash || list.class == ::Hash
             list = self[name] = MongoidExt::FileList.new(list)
           end
 
           list.parent_document = self
+          list.list_name = name
           list
         end
 
         set_callback(:create, :after) do |doc|
           l = doc.send(name)
           l.sync_files
-          doc.save(:validate => false)
+
+          query = doc._updates
+          if !query.blank?
+            doc.collection.update({:_id => doc.id}, query)
+          end
         end
 
         set_callback(:destroy, :before) do |doc|
@@ -89,10 +92,16 @@ module MongoidExt
           end
 
           if self.errors[name].blank?
-            send(opts[:in]).get(name.to_s).put(name.to_s, file)
+            fl = send(opts[:in])
+
+            if file.kind_of?(String)
+              file = StringIO.new(file)
+            end
+
+            fl.get(name.to_s).put(name.to_s, file)
           else
             # we store the errors here because we want to validate before storing the file
-            mm_storage_errors.merge!(errors.errors)
+            storage_errors.merge!(self.errors)
           end
         end
 

data/lib/mongoid_ext/types/embedded_hash.rb

@@ -1,16 +1,33 @@
 class EmbeddedHash < Hash
+  include Mongoid::Fields::Serializable
   include ActiveModel::Validations
 
   def initialize(other = {})
-    other.each do |k,v|
-      self[k] = v
+    super()
+
+    if other
+      other.each do |k,v|
+        self[k] = v
+      end
     end
-    self["_id"] ||= BSON::ObjectId.new.to_s
+
+    self.assign_id
+  end
+
+  def self.allocate
+    obj = super
+    obj.assign_id
+
+    obj
   end
 
   def self.field(name, opts = {})
     define_method(name) do
-      self[name.to_s] ||= opts[:default].kind_of?(Proc) ? opts[:default].call : opts[:default]
+      if fetch(name.to_s, nil).nil?
+        self[name.to_s] = opts[:default].kind_of?(Proc) ? opts[:default].call : opts[:default]
+      else
+        self[name.to_s]
+      end
     end
 
     define_method("#{name}=") do |v|
@@ -19,7 +36,25 @@ class EmbeddedHash < Hash
   end
 
   def id
-      self["_id"]
+    self["_id"]
   end
   alias :_id :id
+
+  def serialize(v)
+    v
+  end
+
+  def deserialize(v)
+    self.class.new(v)
+  end
+
+#   def method_missing(name, *args, &block)
+#     @table.send(name, *args, &block)
+#   end
+
+  def assign_id
+    if fetch("_id", nil).nil?
+      self["_id"] = BSON::ObjectId.new.to_s
+    end
+  end
 end

data/lib/mongoid_ext/types/open_struct.rb

@@ -1,15 +1,19 @@
 require 'ostruct'
 
-class OpenStruct
-  def self.set(value)
-    value.nil? ? nil : value.to_hash
-  end
+module MongoidExt
+  class OpenStruct < ::OpenStruct
+    include Mongoid::Fields::Serializable
 
-  def self.get(value)
-    value.nil? ? nil : OpenStruct.new(value || {})
-  end
+    def serialize(value)
+      value.nil? ? nil : value.to_hash
+    end
+
+    def deserialize(value)
+      value.nil? ? nil : OpenStruct.new(value || {})
+    end
 
-  def to_hash
-    send(:table)
+    def to_hash
+      send(:table)
+    end
   end
 end

data/lib/mongoid_ext/types/timestamp.rb

@@ -1,15 +1,17 @@
 class Timestamp
-  def self.get(value)
+  include Mongoid::Fields::Serializable
+
+  def deserialize(value)
     if value.nil? || value == ''
       nil
     else
-      Time.zone.at(value.to_i)
+      ::Time.zone.at(value.to_i)
     end
   end
 
-  def self.set(value)
+  def serialize(value)
     value.to_i
   end
 end
 
-Time.zone ||= 'UTC'
+::Time.zone ||= 'UTC'

data/lib/mongoid_ext/types/translation.rb

@@ -1,4 +1,6 @@
 class Translation < String
+  include Mongoid::Fields::Serializable
+
   attr_accessor :keys
 
   def initialize(*args)
@@ -33,13 +35,13 @@ class Translation < String
     tr
   end
 
-  def self.set(value)
+  def serialize(value)
     return value.keys if value.kind_of?(self)
 
     @keys
   end
 
-  def self.get(value)
+  def deserialize(value)
     return value if value.kind_of?(self)
 
     result = self.new

data/lib/mongoid_ext/versioning.rb

@@ -3,7 +3,6 @@ module Versioning
   def self.included(klass)
     klass.class_eval do
       extend ClassMethods
-      include InstanceMethods
 
       cattr_accessor :versionable_options
 
@@ -17,92 +16,90 @@ module Versioning
     end
   end
 
-  module InstanceMethods
-    def rollback!(pos = nil)
-      pos = self.versions_count-1 if pos.nil?
-      version = self.version_at(pos)
+  def rollback!(pos = nil)
+    pos = self.versions_count-1 if pos.nil?
+    version = self.version_at(pos)
 
-      if version
-        version.data.each do |key, value|
-          self.send("#{key}=", value)
-        end
-
-        owner_field = self.class.versionable_options[:owner_field]
-        self[owner_field] = version[owner_field] if !self.changes.include?(owner_field)
-        self.updated_at = version.date if self.respond_to?(:updated_at) && !self.updated_at_changed?
+    if version
+      version.data.each do |key, value|
+        self.send("#{key}=", value)
       end
 
-      @rolling_back = true
-      r = save!
-      @rolling_back = false
-      r
+      owner_field = self.class.versionable_options[:owner_field]
+      self[owner_field] = version[owner_field] if !self.changes.include?(owner_field)
+      self.updated_at = version.date if self.respond_to?(:updated_at) && !self.updated_at_changed?
     end
 
-    def load_version(pos = nil)
-      pos = self.versions_count-1 if pos.nil?
-      version = self.version_at(pos)
+    @rolling_back = true
+    r = save!
+    @rolling_back = false
+    r
+  end
+
+  def load_version(pos = nil)
+    pos = self.versions_count-1 if pos.nil?
+    version = self.version_at(pos)
 
-      if version
-        version.data.each do |key, value|
-          self.send("#{key}=", value)
-        end
+    if version
+      version.data.each do |key, value|
+        self.send("#{key}=", value)
       end
     end
+  end
 
-    def diff(key, pos1, pos2, format = :html)
-      version1 = self.version_at(pos1)
-      version2 = self.version_at(pos2)
+  def diff(key, pos1, pos2, format = :html)
+    version1 = self.version_at(pos1)
+    version2 = self.version_at(pos2)
 
-      Differ.diff(version1.content(key), version2.content(key)).format_as(format).html_safe
-    end
+    Differ.diff(version1.content(key), version2.content(key)).format_as(format).html_safe
+  end
 
-    def diff_by_word(key, pos1, pos2, format = :html)
-      version1 = self.version_at(pos1)
-      version2 = self.version_at(pos2)
+  def diff_by_word(key, pos1, pos2, format = :html)
+    version1 = self.version_at(pos1)
+    version2 = self.version_at(pos2)
 
-      Differ.diff_by_word(version1.content(key), version2.content(key)).format_as(format).html_safe
-    end
+    Differ.diff_by_word(version1.content(key), version2.content(key)).format_as(format).html_safe
+  end
 
-    def diff_by_line(key, pos1, pos2, format = :html)
-      version1 = self.version_at(pos1)
-      version2 = self.version_at(pos2)
+  def diff_by_line(key, pos1, pos2, format = :html)
+    version1 = self.version_at(pos1)
+    version2 = self.version_at(pos2)
 
-      Differ.diff_by_line(version1.content(key), version2.content(key)).format_as(format).html_safe
-    end
+    Differ.diff_by_line(version1.content(key), version2.content(key)).format_as(format).html_safe
+  end
 
-    def diff_by_char(key, pos1, pos2, format = :html)
-      version1 = self.version_at(pos1)
-      version2 = self.version_at(pos2)
+  def diff_by_char(key, pos1, pos2, format = :html)
+    version1 = self.version_at(pos1)
+    version2 = self.version_at(pos2)
 
-      Differ.diff_by_char(version1.content(key), version2.content(key)).format_as(format).html_safe
-    end
+    Differ.diff_by_char(version1.content(key), version2.content(key)).format_as(format).html_safe
+  end
 
-    def current_version
-      version_klass.new(:data => self.attributes, self.class.versionable_options[:owner_field] => (self.updated_by_id_was || self.updated_by_id), :created_at => Time.now)
-    end
+  def current_version
+    version_klass.new(:data => self.attributes, self.class.versionable_options[:owner_field] => (self.updated_by_id_was || self.updated_by_id), :created_at => Time.now)
+  end
 
-    def version_at(pos)
-      case pos.to_s
-      when "current"
-        current_version
-      when "first"
-        version_klass.find(self.version_ids.first)
-      when "last"
-        version_klass.find(self.version_ids.last)
-      else
-        if version_id = self.version_ids[pos]
-          version_klass.find(self.version_ids[pos])
-        end
+  def version_at(pos)
+    case pos.to_s
+    when "current"
+      current_version
+    when "first"
+      version_klass.find(self.version_ids.first)
+    when "last"
+      version_klass.find(self.version_ids.last)
+    else
+      if version_id = self.version_ids[pos]
+        version_klass.find(self.version_ids[pos])
       end
     end
+  end
 
-    def versions
-      version_klass.where(:target_id => self.id)
-    end
+  def versions
+    version_klass.where(:target_id => self.id)
+  end
 
-    def version_klass
-      self.class.version_klass
-    end
+  def version_klass
+    self.class.version_klass
   end
 
   module ClassMethods

data/lib/mongoid_ext/voteable.rb

@@ -46,12 +46,12 @@ module MongoidExt
 
     def add_vote!(value, voter_id, &block)
       if embedded?
-        updates = {self._position+".votes_count" => 1,
-                   self._position+".votes_average" => value.to_i}
+        updates = {self.atomic_position+".votes_count" => 1,
+                   self.atomic_position+".votes_average" => value.to_i}
         if value == 1
-          updates[self._position+".votes_up"] = 1
+          updates[self.atomic_position+".votes_up"] = 1
         elsif value == -1
-          updates[self._position+".votes_down"] = 1
+          updates[self.atomic_position+".votes_down"] = 1
         end
 
         self._parent.increment(updates)
@@ -73,12 +73,12 @@ module MongoidExt
 
     def remove_vote!(value, voter_id, &block)
       if embedded?
-        updates = {self._position+".votes_count" => -1,
-                   self._position+".votes_average" => -value.to_i}
+        updates = {self.atomic_position+".votes_count" => -1,
+                   self.atomic_position+".votes_average" => -value.to_i}
         if value == 1
-          updates[self._position+".votes_up"] = -1
+          updates[self.atomic_position+".votes_up"] = -1
         elsif value == -1
-          updates[self._position+".votes_down"] = -1
+          updates[self.atomic_position+".votes_down"] = -1
         end
 
         self._parent.increment(updates)

data/mongoid_ext.gemspec

@@ -4,15 +4,14 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{mongoid_ext}
-  s.version = "0.6.2"
+  s.name = "mongoid_ext"
+  s.version = "0.7.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["David A. Cuadrado"]
-  s.date = %q{2011-07-15}
-  s.default_executable = %q{mongoid_console}
-  s.description = %q{mongoid plugins}
-  s.email = %q{krawek@gmail.com}
+  s.date = "2012-07-27"
+  s.description = "mongoid plugins"
+  s.email = "krawek@gmail.com"
   s.executables = ["mongoid_console"]
   s.extra_rdoc_files = [
     "LICENSE",
@@ -74,17 +73,16 @@ Gem::Specification.new do |s|
     "test/types/test_set.rb",
     "test/types/test_timestamp.rb"
   ]
-  s.homepage = %q{http://github.com/dcu/mongoid_ext}
+  s.homepage = "http://github.com/dcu/mongoid_ext"
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{mongoid plugins}
+  s.rubygems_version = "1.8.24"
+  s.summary = "mongoid plugins"
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<mongoid>, ["~> 2"])
+      s.add_runtime_dependency(%q<mongoid>, ["~> 2.3"])
       s.add_runtime_dependency(%q<uuidtools>, [">= 2.1.1"])
       s.add_runtime_dependency(%q<i18n>, [">= 0"])
       s.add_runtime_dependency(%q<tzinfo>, [">= 0"])
@@ -99,7 +97,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<mocha>, ["~> 0.9.4"])
       s.add_development_dependency(%q<timecop>, [">= 0"])
     else
-      s.add_dependency(%q<mongoid>, ["~> 2"])
+      s.add_dependency(%q<mongoid>, ["~> 2.3"])
       s.add_dependency(%q<uuidtools>, [">= 2.1.1"])
       s.add_dependency(%q<i18n>, [">= 0"])
       s.add_dependency(%q<tzinfo>, [">= 0"])
@@ -115,7 +113,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<timecop>, [">= 0"])
     end
   else
-    s.add_dependency(%q<mongoid>, ["~> 2"])
+    s.add_dependency(%q<mongoid>, ["~> 2.3"])
     s.add_dependency(%q<uuidtools>, [">= 2.1.1"])
     s.add_dependency(%q<i18n>, [">= 0"])
     s.add_dependency(%q<tzinfo>, [">= 0"])