mongoid_ext 0.6.1

data/lib/mongoid_ext/random.rb

@@ -0,0 +1,23 @@
+module MongoidExt
+  module Random
+    extend ActiveSupport::Concern
+
+    included do
+      field :_random, :type => Float, :default => lambda{rand}
+      field :_random_times, :type => Float, :default => 0.0
+
+      index :_random
+      index :_random_times
+    end
+
+    module ClassMethods
+      def random(conditions = {})
+        r = rand()
+        doc = self.where(conditions.merge(:_random.gte => r)).order_by(:_random_times.asc, :_random.asc).first ||
+              self.where(conditions.merge(:_random.lte => r)).order_by(:_random_times.asc, :_random.asc).first
+        doc.inc(:_random_times, 1.0) if doc
+        doc
+      end
+    end
+  end
+end

data/lib/mongoid_ext/slugizer.rb

@@ -0,0 +1,84 @@
+# @author David Cuadrado
+module MongoidExt
+  # Slugizes a given key
+  # Usage:
+  #   class MyModel
+  #     include Mongoid::Document
+  #     include MongoidExt::Slugizer
+  #     field :name
+  #     slug_key :name, :callback_type => :before_save
+  #   end
+  #
+  module Slugizer
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        extend Finder
+
+        field :slug, :type => String, :index => true
+      end
+    end
+
+    def to_param
+      self.slug.blank? ? self.id.to_s : self.slug
+    end
+
+    protected
+
+    def generate_slug
+      return false if self[self.class.slug_key].blank?
+      max_length = self.class.slug_options[:max_length]
+      min_length = self.class.slug_options[:min_length] || 0
+
+      slug = self[self.class.slug_key].parameterize.to_s
+      slug = slug[0, max_length] if max_length
+
+      if slug.size < min_length
+        slug = nil
+      end
+
+      if slug && self.class.slug_options[:add_prefix]
+        key = UUIDTools::UUID.random_create.hexdigest[0,4] #optimize
+        self.slug = key+"-"+slug
+      else
+        self.slug = slug
+      end
+    end
+
+    module ClassMethods
+      # marks a field as sluggable (default key is :name)
+      # == Parameters
+      # @param [Symbol] key the field to be slugized
+      # @param [Hash] options options to configure the process
+      # @return 
+      #   
+      def slug_key(key = :name, options = {})
+        @slug_options ||= options
+        @callback_type ||= begin
+          type = options[:callback_type] || :before_validation
+
+          send(type, :generate_slug)
+
+          type
+        end
+
+        @slug_key ||= key
+      end
+      class_eval do
+        attr_reader :slug_options
+      end
+    end
+
+    module Finder
+      # finds a document by slug or id
+      # @param [Strig] id slug or id
+      # @param [Hash] options additional conditions
+      def by_slug(id, options = {})
+        self.where(options.merge({:slug => id})).first || self.where(options.merge({:_id => id})).first
+      end
+      alias :find_by_slug_or_id :by_slug
+    end
+  end
+end
+
+Mongoid::Criteria.send(:include, MongoidExt::Slugizer::Finder)

data/lib/mongoid_ext/storage.rb

@@ -0,0 +1,110 @@
+module MongoidExt
+  module Storage
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+
+        validate :add_mm_storage_errors
+        file_list :file_list
+      end
+    end
+
+    def put_file(name, io, options = {})
+      file_list = send(options.delete(:in) || :file_list)
+      file_list.put(name, io, options)
+    end
+
+    def fetch_file(name, options = {})
+      file_list = send(options.delete(:in) || :file_list)
+      file_list.get(name)
+    end
+
+    def delete_file(id, options = {})
+      file_list = send(options.delete(:in) || :file_list)
+      file_list.delete(id)
+    end
+
+    def files(options = {})
+      file_list = send(options.delete(:in) || :file_list)
+      file_list.files
+    end
+
+    def mm_storage_errors
+      @mm_storage_errors ||= {}
+    end
+
+    def add_mm_storage_errors
+      mm_storage_errors.each do |k, msgs|
+        msgs.each do |msg|
+          self.errors.add(k, msg)
+        end
+      end
+    end
+
+    module ClassMethods
+      def gridfs
+        @gridfs ||= Mongo::Grid.new(self.db)
+      end
+
+      def file_list(name)
+        field name, :type => MongoidExt::FileList
+        define_method(name) do
+          list = self[name]
+
+          if list.nil?
+            list = self[name] = MongoidExt::FileList.new
+          elsif list.class == BSON::OrderedHash || list.class == Hash
+            list = self[name] = MongoidExt::FileList.new(list)
+          end
+
+          list.parent_document = self
+          list
+        end
+
+        set_callback(:create, :after) do |doc|
+          l = doc.send(name)
+          l.sync_files
+          doc.save(:validate => false)
+        end
+
+        set_callback(:destroy, :before) do |doc|
+          doc.send(name).destroy_files
+        end
+      end
+
+      def file_key(name, opts = {})
+        opts[:in] ||= :file_list
+
+        define_method("#{name}=") do |file|
+          if opts[:max_length] && file.respond_to?(:size) && file.size > opts[:max_length]
+            errors.add(name, I18n.t("mongoid_ext.storage.errors.max_length", :default => "file is too long. max length is #{opts[:max_length]} bytes"))
+          end
+
+          if cb = opts[:validate]
+            if cb.kind_of?(Symbol)
+              send(opts[:validate], file)
+            elsif cb.kind_of?(Proc)
+              cb.call(file)
+            end
+          end
+
+          if self.errors[name].blank?
+            send(opts[:in]).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)
+          end
+        end
+
+        define_method(name) do
+          send(opts[:in]).get(name.to_s)
+        end
+
+        define_method("has_#{name}?") do
+          send(opts[:in]).has_key?(name.to_s)
+        end
+      end
+      private
+    end
+  end
+end

data/lib/mongoid_ext/tags.rb

@@ -0,0 +1,26 @@
+module MongoidExt
+  module Tags
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+
+        field :tags, :type => Array, :index => true, :default => []
+      end
+    end
+
+    module ClassMethods
+      def tag_cloud(conditions = {}, limit = 30)
+        self.db.nolock_eval("function(collection, q,l) { return tag_cloud(collection, q,l); }", self.collection_name, conditions, limit)
+      end
+
+      # Model.find_with_tags("budget", "big").limit(4)
+      def find_with_tags(*tags)
+        self.all(:conditions => {:tags.in => tags})
+      end
+
+      def find_tags(regex, conditions = {}, limit = 30)
+        self.db.nolock_eval("function(collection, a,b,c) { return find_tags(collection, a,b,c); }", self.collection_name, regex, conditions, limit)
+      end
+    end
+  end
+end

data/lib/mongoid_ext/types/embedded_hash.rb

@@ -0,0 +1,25 @@
+class EmbeddedHash < Hash
+  include ActiveModel::Validations
+
+  def initialize(other = {})
+    other.each do |k,v|
+      self[k] = v
+    end
+    self["_id"] ||= BSON::ObjectId.new.to_s
+  end
+
+  def self.field(name, opts = {})
+    define_method(name) do
+      self[name.to_s] ||= opts[:default].kind_of?(Proc) ? opts[:default].call : opts[:default]
+    end
+
+    define_method("#{name}=") do |v|
+      self[name.to_s] = v
+    end
+  end
+
+  def id
+      self["_id"]
+  end
+  alias :_id :id
+end

data/lib/mongoid_ext/types/open_struct.rb

@@ -0,0 +1,15 @@
+require 'ostruct'
+
+class OpenStruct
+  def self.set(value)
+    value.nil? ? nil : value.to_hash
+  end
+
+  def self.get(value)
+    value.nil? ? nil : OpenStruct.new(value || {})
+  end
+
+  def to_hash
+    send(:table)
+  end
+end

data/lib/mongoid_ext/types/timestamp.rb

@@ -0,0 +1,15 @@
+class Timestamp
+  def self.get(value)
+    if value.nil? || value == ''
+      nil
+    else
+      Time.zone.at(value.to_i)
+    end
+  end
+
+  def self.set(value)
+    value.to_i
+  end
+end
+
+Time.zone ||= 'UTC'

data/lib/mongoid_ext/types/translation.rb

@@ -0,0 +1,51 @@
+class Translation < String
+  attr_accessor :keys
+
+  def initialize(*args)
+    super
+    @keys = {}
+    @keys["default"] = "en"
+  end
+
+  def []=(lang, text)
+    @keys[lang.to_s] = text
+  end
+
+  def [](lang)
+    @keys[lang.to_s]
+  end
+
+  def languages
+    langs = @keys.keys
+    langs.delete("default")
+    langs
+  end
+
+  def default_language=(lang)
+    @keys["default"] = lang
+    self.replace(@keys[lang.to_s])
+  end
+
+  def self.build(keys, default = "en")
+    tr = self.new
+    tr.keys = keys
+    tr.default_language = default
+    tr
+  end
+
+  def self.set(value)
+    return value.keys if value.kind_of?(self)
+
+    @keys
+  end
+
+  def self.get(value)
+    return value if value.kind_of?(self)
+
+    result = self.new
+    result.keys = value
+    result.default_language = value["default"] || "en"
+
+    result
+  end
+end

data/lib/mongoid_ext/update.rb

@@ -0,0 +1,11 @@
+module MongoidExt
+  module Update
+    def safe_update(white_list, values)
+      white_list.each do |key|
+        send("#{key}=", values[key]) if values.has_key?(key)
+      end
+    end
+  end
+end
+
+Mongoid::Document.send(:include, MongoidExt::Update)

data/lib/mongoid_ext/versioning.rb

@@ -0,0 +1,189 @@
+module MongoidExt
+module Versioning
+  def self.included(klass)
+    klass.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+
+      cattr_accessor :versionable_options
+
+      attr_accessor :rolling_back
+      field :version_message
+
+      field :versions_count, :type => Integer, :default => 0
+      field :version_ids, :type => Array, :default => []
+
+      before_save :save_version, :if => Proc.new { |d| !d.rolling_back }
+    end
+  end
+
+  module InstanceMethods
+    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?
+      end
+
+      @rolling_back = true
+      save!
+    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
+      end
+    end
+
+    def diff(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
+
+    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
+      end
+    end
+
+    def versions
+      version_klass.where(:target_id => self.id)
+    end
+
+    def version_klass
+      self.class.version_klass
+    end
+  end
+
+  module ClassMethods
+    def version_klass
+      parent_klass = self
+      @version_klass ||= Class.new do
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        cattr_accessor :parent_class
+        self.parent_class = parent_klass
+
+        self.collection_name = "#{self.parent_class.collection_name}.versions"
+
+        identity :type => String
+        field :message, :type => String
+        field :data, :type => Hash
+
+        referenced_in :owner, :class_name => parent_klass.versionable_options[:user_class]
+
+        referenced_in :target, :polymorphic => true
+
+        after_create :add_version
+
+        validates_presence_of :target_id
+
+        def content(key)
+          cdata = self.data[key]
+          if cdata.respond_to?(:join)
+            cdata.join(" ")
+          else
+            cdata || ""
+          end
+        end
+
+        private
+        def add_version
+          self.class.parent_class.push({:_id => self.target_id}, {:version_ids => self.id})
+          self.class.parent_class.increment({:_id => self.target_id}, {:versions_count => 1})
+        end
+      end
+    end
+
+    # example:
+    #     class Foo
+    #       include Mongoid::Document
+    #       include MongoidExt::Versioning
+    #       versionable_keys :field1, :field2, :field3, :user_class => "Customer", :owner_field => "updated_by_id"
+    #       ...
+    #     end
+    #
+    def versionable_keys(*keys)
+      self.versionable_options = keys.extract_options!
+      self.versionable_options[:owner_field] ||= "user_id"
+      self.versionable_options[:owner_field] = self.versionable_options[:owner_field].to_s
+
+      relationship = self.relations[self.versionable_options[:owner_field].sub(/_id$/, "")]
+      if !relationship
+        raise ArgumentError, "the supplied :owner_field => #{self.versionable_options[:owner_field].inspect} option is invalid"
+      end
+      self.versionable_options[:user_class] = relationship.class_name
+
+      define_method(:save_version) do
+        data = {}
+        message = ""
+        keys.each do |key|
+          if change = changes[key.to_s]
+            data[key.to_s] = change.first
+          else
+            data[key.to_s] = self[key]
+          end
+        end
+
+        if message_changes = self.changes["version_message"]
+          message = message_changes.first
+        else
+          version_message = ""
+        end
+
+        uuser_id = send(self.versionable_options[:owner_field]+"_was")||send(self.versionable_options[:owner_field])
+        if !self.new? && !data.empty? && uuser_id
+          max_versions = self.versionable_options[:max_versions].to_i
+          if self.version_ids.size >= max_versions
+            old = self.version_ids.slice!(0, max_versions)
+            self.class.skip_callback(:save, :before, :save_version)
+            self.version_klass.delete_all(:_ids => old)
+            self.save
+            self.class.set_callback(:save, :before, :save_version)
+          end
+
+          self.version_klass.create({
+            'data' => data,
+            'owner_id' => uuser_id,
+            'target' => self,
+            'message' => message
+          })
+        end
+      end
+
+      define_method(:versioned_keys) do
+        keys
+      end
+    end
+  end
+end
+end
+