mongoid-ordering 0.1.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Douwe Maan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,139 @@
+# mongoid-ordering  [![Build Status](https://secure.travis-ci.org/DouweM/mongoid-ordering.png?branch=master)](http://travis-ci.org/DouweM/mongoid-ordering)
+
+mongoid-ordering makes it easy to keep your Mongoid documents in order.
+
+Most of mongoid-ordering is based on the 
+`Mongoid::Tree::Ordering` module from the
+[mongoid-tree](https://github.com/benedikt/mongoid-tree) gem. I thought
+the ordering logic would be useful outside of the tree context as well, so I 
+extracted it into the gem you're looking at right now.
+
+## Features
+
+* Automatically order your query results by a new `position` attribute.
+* Allow documents to be ordered within a certain scope.
+* Handle changes in position when a document is destroyed or when a document is 
+  moved outside of this scope.
+* Tons of utility methods to make working with ordered documents incredibly easy.
+
+## Requirements
+
+* mongoid (~> 3.0)
+
+## Installation
+
+Add the following to your Gemfile:
+
+```ruby
+gem "mongoid-ordering"
+```
+
+And tell Bundler to install the new gem:
+
+```
+bundle install
+```
+
+## Usage
+
+Include the `Mongoid::Ordering` module in your document class:
+
+```ruby
+class Book
+  include Mongoid::Document
+  include Mongoid::Ordering
+
+  ...
+end
+```
+
+This will take care of everything to get you going. 
+
+If you want to specify a scope within which to keep the documents in order, 
+you can like this:
+
+```ruby
+class Book
+  include Mongoid::Document
+  include Mongoid::Ordering
+
+  belongs_to :author
+
+  ordered scope: :author
+
+  ...
+end
+```
+
+You will now have access to the following methods:
+
+```ruby
+# Retrieve siblings positioned above this document.
+book.higher_siblings
+# Retrieve siblings positioned below this document.
+book.lower_siblings
+# Retrieve the highest sibling.
+book.highest_sibling
+# Retrieve the lowest sibling.
+book.lowest_sibling
+
+# Is this the highest sibling?
+book.at_top?
+# Is this the lowest sibling?
+book.at_bottom?
+
+# Move document to the top.
+book.move_to_top
+# Move document to the bottom.
+book.move_to_bottom
+# Move document one position up.
+book.move_up
+# Move document one position down.
+book.move_down
+# Move document above another document.
+book.move_above(other_book)
+# Move document below another document.
+book.move_below(other_book)
+```
+
+mongoid-ordering uses [mongoid-siblings](https://github.com/DouweM/mongoid-siblings) to get all of this to work, so you'll get the following methods as a bonus:
+
+```ruby
+# Retrieve document's siblings
+book.siblings
+# Retrieve document's siblings and itself
+book.siblings_and_self
+# Is this document a sibling of the other document?
+book.sibling_of?(other_book)
+# Make document a sibling of the other document.
+# This will move this book to the same scope as the other book.
+book.sibling_of!(other_book)
+```
+
+## Full documentation
+See [this project's RubyDoc.info page](http://rubydoc.info/github/DouweM/mongoid-ordering/master/frames).
+
+## Known issues
+See [the GitHub Issues page](https://github.com/DouweM/mongoid-ordering/issues).
+
+## License
+Copyright (c) 2012 Douwe Maan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.load("mongoid-ordering.gemspec")
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc "Build the .gem file"
+task :build do
+  system "gem build #{spec.name}.gemspec"
+end
+
+desc "Push the .gem file to rubygems.org"
+task release: :build do
+  system "gem push #{spec.name}-#{spec.version}.gem"
+end

data/lib/mongoid/ordering.rb

@@ -0,0 +1,255 @@
+module Mongoid
+
+  # Add 'position' field, multiple methods and multiple callbacks to help with 
+  # ordering your documents.
+  module Ordering
+    extend ActiveSupport::Concern
+    include Mongoid::Siblings
+    
+    included do
+      cattr_accessor :ordering_scopes
+      self.ordering_scopes = []
+      
+      field :position, type: Integer
+
+      default_scope asc(:position)
+
+      before_save :assign_default_position
+      before_save :reposition_former_siblings, if: :sibling_reposition_required?
+      after_destroy :move_lower_siblings_up
+    end
+    
+    module ClassMethods
+      # Sets options used for ordering.
+      #
+      # @example Set options.
+      #   class Book
+      #     include Mongoid::Document
+      #     include Mongoid::Ordering
+      #   
+      #     belongs_to :author
+      #   
+      #     ordered scope: :author
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Array<Symbol>, Symbol ] scope One or more relations or
+      #   attributes that will determine the scope within which to keep the
+      #   documents in order.
+      def ordered(options = {})
+        self.default_sibling_scope = self.ordering_scopes = Array.wrap(options[:scope]).compact
+      end
+    end
+
+    # Returns siblings positioned above this document.
+    # Siblings with a position lower than this document's position.
+    #
+    # @example Retrieve siblings positioned above this document.
+    #   book.higher_siblings
+    #
+    # @return [ Mongoid::Criteria ] Criteria to retrieve the document's higher siblings.
+    def higher_siblings
+      self.siblings.where(:position.lt => self.position)
+    end
+
+    # Returns siblings positioned below this document.
+    # Siblings with a position greater than this document's position.
+    #
+    # @example Retrieve siblings positioned below this document.
+    #   book.lower_siblings
+    #
+    # @return [ Mongoid::Criteria ] Criteria to retrieve the document's lower siblings.
+    def lower_siblings
+      self.siblings.where(:position.gt => self.position)
+    end
+
+    # Returns the highest sibling (could be self).
+    #
+    # @example Retrieve the highest sibling.
+    #   book.highest_sibling
+    #
+    # @return [ Mongoid::Document ] The highest sibling.
+    def highest_sibling
+      self.siblings_and_self.first
+    end
+
+    # Returns the lowest sibling (could be self).
+    #
+    # @example Retrieve the lowest sibling.
+    #   book.lowest_sibling
+    #
+    # @return [ Mongoid::Document ] The lowest sibling
+    def lowest_sibling
+      self.siblings_and_self.last
+    end
+
+    # Is this the highest sibling?
+    #
+    # @example Is this the highest sibling?
+    #   book.at_top?
+    #
+    # @return [ Boolean ] True if this document is the highest sibling.
+    def at_top?
+      self.higher_siblings.empty?
+    end
+
+    # Is this the lowest sibling?
+    #
+    # @example Is this the lowest sibling?
+    #   book.at_bottom?
+    #
+    # @return [ Boolean ] True if this document is the lowest sibling.
+    def at_bottom?
+      self.lower_siblings.empty?
+    end
+
+    # Moves this document above all of its siblings.
+    #
+    # @example Move document to the top.
+    #   book.move_to_top
+    #
+    # @return [ Boolean ] True if the document was moved to the top or was 
+    #   already there.
+    def move_to_top
+      return true if at_top?
+      self.move_above(self.highest_sibling)
+    end
+
+    # Moves this document below all of its siblings.
+    #
+    # @example Move document to the bottom.
+    #   book.move_to_bottom
+    #
+    # @return [ Boolean ] True if the document was moved to the bottom or was 
+    #   already there.
+    def move_to_bottom
+      return true if at_bottom?
+      self.move_below(self.lowest_sibling)
+    end
+
+    # Moves this document one position up.
+    #
+    # @example Move document one position up.
+    #   book.move_up
+    def move_up
+      return if at_top?
+      self.siblings.where(position: self.position - 1).first.inc(:position, 1)
+      self.inc(:position, -1)
+    end
+
+    # Moves this document one position down.
+    #
+    # @example Move document one position down.
+    #   book.move_down
+    def move_down
+      return if at_bottom?
+      self.siblings.where(position: self.position + 1).first.inc(:position, -1)
+      self.inc(:position, 1)
+    end
+
+    # Moves this document above the specified document.
+    #
+    # This method changes this document's scope values if necessary.
+    #
+    # @example Move document above another document.
+    #   book.move_above(other_book)
+    #
+    # @param [ Mongoid::Document ] other The document to Moves this document 
+    #   above.
+    def move_above(other)
+      return false unless self.sibling_of!(other)
+
+      if self.position > other.position
+        new_position = other.position
+        other.lower_siblings.and(:position.lt => self.position).each { |s| s.inc(:position, 1) }
+        other.inc(:position, 1)
+      else
+        new_position = other.position - 1
+        other.higher_siblings.and(:position.gt => self.position).each { |s| s.inc(:position, -1) }
+      end
+      self.position = new_position
+
+      self.save!
+    end
+
+    # Moves this document below the specified document.
+    #
+    # This method changes this document's scope values if necessary.
+    #
+    # @example Move document below another document.
+    #   book.move_below(other_book)
+    #
+    # @param [ Mongoid::Document ] other The document to Moves this document 
+    #   below.
+    def move_below(other)
+      return false unless self.sibling_of!(other)
+
+      if self.position > other.position
+        new_position = other.position + 1
+        other.lower_siblings.and(:position.lt => self.position).each { |s| s.inc(:position, 1) }
+      else
+        new_position = other.position
+        other.higher_siblings.and(:position.gt => self.position).each { |s| s.inc(:position, -1) }
+        other.inc(:position, -1)
+      end
+      self.position = new_position
+
+      self.save!
+    end
+
+    private  
+
+      def move_lower_siblings_up
+        self.lower_siblings.each { |s| s.inc(:position, -1) }
+      end
+
+      def sibling_reposition_required?
+        return false if self.ordering_scopes.empty?
+        self.ordering_scopes.any? { |scope| attribute_changed?(key_for_scope(scope)) } && persisted?
+      end
+
+      def reposition_former_siblings
+        return if self.ordering_scopes.empty?
+        
+        old_scope_values = {}
+        self.ordering_scopes.each do |scope|
+          scope_metadata = self.reflect_on_association(scope)
+          scope_key = scope_metadata ? scope_metadata.key : scope.to_s
+          
+          if attribute_changed?(scope_key)
+            old_value = attribute_was(scope_key)
+
+            old_scope_values[scope] = if scope_metadata && old_value
+              model = scope_metadata.inverse_type ? attribute_was(scope_metadata.inverse_type) : scope_metadata.klass
+              scope_metadata.criteria(old_value, model).first
+            else
+              old_value
+            end
+          end
+        end
+        
+        former_siblings = self.siblings(scope_values: old_scope_values).where(:position.gt => (attribute_was("position") || 0))
+        former_siblings.each { |s| s.inc(:position,  -1) }
+      end
+
+      def assign_default_position
+        return unless self.position.nil? ||
+                      (self.ordering_scopes.any? { |scope| attribute_changed?(key_for_scope(scope)) } &&
+                       !new_record?)
+
+        siblings = self.siblings
+        self.position = if siblings.empty? || siblings.map(&:position).compact.empty?
+          0
+        else
+          siblings.max(:position).to_i + 1
+        end
+      end
+
+      def key_for_scope(scope)
+        return nil if scope.nil?
+        metadata = self.reflect_on_association(scope)
+        metadata ? metadata.key : scope.to_s
+      end
+  end
+end

data/spec/mongoid/ordering_spec.rb

@@ -0,0 +1,291 @@
+require "spec_helper.rb"
+
+describe Mongoid::Ordering do
+  
+  describe ".ordered" do
+    
+    let(:test_class) {
+      Class.new do
+        include Mongoid::Document
+        include Mongoid::Ordering
+        
+        ordered scope: [:main, :fallback]
+      end
+    }
+    
+    it "sets the default sibling scope and the ordering scopes to the specified scope" do
+      test_class.default_sibling_scope.should eq([:main, :fallback])
+      test_class.ordering_scopes.should       eq([:main, :fallback])
+    end
+  end
+  
+  describe "Instance methods" do
+  
+    let!(:sibling1) { DummyParentDocument.create }  
+    let!(:sibling2) { DummyParentDocument.create }  
+    let!(:sibling3) { DummyParentDocument.create }
+  
+    describe "#lower_siblings" do
+    
+      it "returns the siblings with a higher position" do
+        sibling1.lower_siblings.should eq([sibling2, sibling3])
+      end
+    end
+  
+    describe "#higher_siblings" do
+    
+      it "returns the siblings with a lower position" do
+        sibling3.higher_siblings.should eq([sibling1, sibling2])
+      end
+    end
+  
+    describe "#highest_sibling" do
+    
+      it "returns the first sibling" do
+        sibling2.highest_sibling.should eq(sibling1)
+      end
+    end
+  
+    describe "#lowest_sibling" do
+    
+      it "returns the last sibling" do
+        sibling2.lowest_sibling.should eq(sibling3)
+      end
+    end
+  
+    describe "#at_top?" do
+    
+      context "when the subject is the first sibling" do
+      
+        it "returns true" do
+          sibling1.should be_at_top
+        end
+      end
+    
+      context "when the subject is not the first sibling" do
+      
+        it "returns false" do
+          sibling2.should_not be_at_top
+        end
+      end
+    end
+  
+    describe "#at_bottom?" do
+    
+      context "when the subject is the last sibling" do
+      
+        it "returns true" do
+          sibling3.should be_at_bottom
+        end
+      end
+    
+      context "when the subject is not the last sibling" do
+      
+        it "returns false" do
+          sibling2.should_not be_at_bottom
+        end
+      end
+    end
+  
+    describe "#move_to_top" do
+    
+      it "rearranges the siblings" do
+        sibling3.move_to_top
+      
+        sibling3.siblings_and_self.should eq([sibling3, sibling1, sibling2])
+      end
+    
+      it "properly sets the positions" do
+        sibling3.move_to_top
+      
+        sibling3.reload.position.should eq(0)
+        sibling1.reload.position.should eq(1)
+        sibling2.reload.position.should eq(2)
+      end
+    end
+  
+    describe "#move_to_bottom" do
+    
+      it "rearranges the siblings" do
+        sibling1.move_to_bottom
+      
+        sibling1.siblings_and_self.should eq([sibling2, sibling3, sibling1])
+      end
+    
+      it "properly sets the positions" do
+        sibling1.move_to_bottom
+      
+        sibling2.reload.position.should eq(0)
+        sibling3.reload.position.should eq(1)
+        sibling1.reload.position.should eq(2)
+      end
+    end
+  
+    describe "#move_up" do
+    
+      it "rearranges the siblings" do
+        sibling3.move_up
+      
+        sibling3.siblings_and_self.should eq([sibling1, sibling3, sibling2])
+      end
+    
+      it "properly sets the positions" do
+        sibling3.move_up
+      
+        sibling1.reload.position.should eq(0)
+        sibling3.reload.position.should eq(1)
+        sibling2.reload.position.should eq(2)
+      end
+    end
+  
+    describe "#move_down" do
+    
+      it "rearranges the siblings" do
+        sibling1.move_down
+      
+        sibling1.siblings_and_self.should eq([sibling2, sibling1, sibling3])
+      end
+    
+      it "properly sets the positions" do
+        sibling1.move_down
+      
+        sibling2.reload.position.should eq(0)
+        sibling1.reload.position.should eq(1)
+        sibling3.reload.position.should eq(2)
+      end
+    end
+  
+    describe "#move_above" do
+    
+      context "when the subject was somewhere above the other object" do
+
+        it "rearranges the siblings" do
+          sibling1.move_above(sibling3)
+
+          sibling1.siblings_and_self.should eq([sibling2, sibling1, sibling3])
+        end
+
+        it "properly sets the positions" do
+          sibling1.move_above(sibling3)
+
+          sibling2.reload.position.should eq(0)
+          sibling1.reload.position.should eq(1)
+          sibling3.reload.position.should eq(2)
+        end
+      end
+    
+      context "when the subject was somewhere below the other object" do
+
+        it "rearranges the siblings" do
+          sibling3.move_above(sibling2)
+
+          sibling3.siblings_and_self.should eq([sibling1, sibling3, sibling2])
+        end
+
+        it "properly sets the positions" do
+          sibling3.move_above(sibling2)
+
+          sibling1.reload.position.should eq(0)
+          sibling3.reload.position.should eq(1)
+          sibling2.reload.position.should eq(2)
+        end
+      end
+    end
+  
+    describe "#move_below" do
+    
+      context "when the subject was somewhere above the other object" do
+
+        it "rearranges the siblings" do
+          sibling1.move_below(sibling2)
+
+          sibling1.siblings_and_self.should eq([sibling2, sibling1, sibling3])
+        end
+
+        it "properly sets the positions" do
+          sibling1.move_below(sibling2)
+
+          sibling2.reload.position.should eq(0)
+          sibling1.reload.position.should eq(1)
+          sibling3.reload.position.should eq(2)
+        end
+      end
+    end
+    
+    context "when the subject was somewhere below the other object" do
+
+      it "rearranges the siblings" do
+        sibling3.move_below(sibling1)
+
+        sibling3.siblings_and_self.should eq([sibling1, sibling3, sibling2])
+      end
+
+      it "properly sets the positions" do
+        sibling3.move_below(sibling1)
+
+        sibling1.reload.position.should eq(0)
+        sibling3.reload.position.should eq(1)
+        sibling2.reload.position.should eq(2)
+      end
+    end
+  end
+  
+  describe "creating a document" do
+    
+    context "when no siblings exist yet" do
+      
+      it "sets the subject's position to 0" do
+        DummyParentDocument.create.position.should eq(0)
+      end
+    end
+    
+    context "when a sibling already exist" do
+      
+      let!(:sibling) { DummyParentDocument.create }  
+      
+      it "sets the subject's position to the highest position plus 1" do
+        DummyParentDocument.create.position.should eq(1)
+      end
+    end
+  end
+  
+  describe "moving a document to another parent" do
+    
+    let!(:parent1)        { DummyParentDocument.create }
+    let!(:parent1_child1) { DummyChildDocument.create(parent: parent1) }
+    let!(:parent1_child2) { DummyChildDocument.create(parent: parent1) }
+    let!(:parent1_child3) { DummyChildDocument.create(parent: parent1) }
+    let!(:parent2)        { DummyParentDocument.create }
+    let!(:parent2_child1) { DummyChildDocument.create(parent: parent2) }
+    let!(:parent2_child2) { DummyChildDocument.create(parent: parent2) }
+    let!(:parent2_child3) { DummyChildDocument.create(parent: parent2) }
+    
+    before(:each) do
+      parent1_child2.parent = parent2
+      parent1_child2.save
+    end
+    
+    it "moves lower siblings up" do
+      parent1_child1.reload.position.should eq(0)
+      parent1_child3.reload.position.should eq(1)
+    end
+    
+    it "sets the subject's position to the highest position under the new parent plus 1" do
+      parent1_child2.reload.position.should eq(3)
+    end
+  end
+  
+  describe "destroying a document" do
+  
+    let!(:sibling1) { DummyParentDocument.create }  
+    let!(:sibling2) { DummyParentDocument.create }  
+    let!(:sibling3) { DummyParentDocument.create }
+    
+    it "moves lower siblings up" do
+      sibling2.destroy
+      
+      sibling1.reload.position.should eq(0)
+      sibling3.reload.position.should eq(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "bundler/setup"
+
+require "mongoid"
+require "mongoid/siblings"
+require "mongoid/ordering"
+
+require "rspec"
+
+Mongoid.configure do |config|
+  config.connect_to "mongoid_ordering_test"
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.after :each do
+    Mongoid::Config.purge!
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,19 @@
+class DummyParentDocument
+  include Mongoid::Document
+  include Mongoid::Ordering
+  
+  ordered scope: nil
+  
+  has_many :children, class_name: "DummyChildDocument",
+                      inverse_of: :parent
+end
+
+class DummyChildDocument
+  include Mongoid::Document
+  include Mongoid::Ordering
+  
+  ordered scope: :parent
+  
+  belongs_to :parent, class_name: DummyParentDocument.to_s,
+                      inverse_of: :children
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-ordering
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Douwe Maan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &70134351207600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70134351207600
+- !ruby/object:Gem::Dependency
+  name: mongoid-siblings
+  requirement: &70134351205960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70134351205960
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70134351204840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70134351204840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70134351203100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70134351203100
+description: mongoid-ordering makes it easy to keep your Mongoid documents in order.
+email: douwe@selenight.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/ordering.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+- spec/mongoid/ordering_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+homepage: https://github.com/DouweM/mongoid-ordering
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -533634391627392618
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -533634391627392618
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Easy ordering of your Mongoid documents.
+test_files:
+- spec/mongoid/ordering_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb