mongoid_listable 0.2.1 → 0.2.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2IzMjdhOTU3NzdkZTA2OWVkOTkzYTkzNjA2NmEwYmM3Y2MyN2E1OQ==
+    YWE5MDIwMmJjOWRhNTM2NzU2Yzg2OWYzYTI4YmM4NGQ3ODczYjg0Mw==
   data.tar.gz: !binary |-
-    Mzc3MGVmOWRjNmQ4Yzc3YmI0YmE3Y2I2ODU5MzcxNDliMDE2N2NiZA==
+    MDJmNTM5NzAyYjM4MGU2ZjEyZWFiYjY0NmY2YWYzMzEyMDVlYmRlYQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NjgxM2UzY2RiMDMyYWQ5ZTIzMTllZTQ3NmU4MjIzYzdlNDUwZDU2ZjJkNzFm
-    ODgwNmE4NTk4YzNjNWRkZWRmZjhlODU1YmIyMjkyMzAyYmY0MjZiMGMxOGY0
-    Zjk1Y2U2ZGFhMmFkYzg0MmEzODY2N2U3MDVlMWYxNGIyMGJmMjk=
+    M2JhNWFhMjcwNjUxMTE5OGM1MzU1OTZlN2U3NDNiNzI2N2M5MjY5YmQxNWY1
+    MzBiMDkzZDliOTJjNTNkZmQyN2MwYjU3NDhiZGE3NmU3YTdhZmFiYWRmOGU2
+    YzBkNzM3Njg3MTA0ODg2ZTQ5MzY1YTc1YWM4Yzk1Y2NmNWQ5NjQ=
   data.tar.gz: !binary |-
-    MTEzMjQyNmY1MmVkZWQ3ZWZmNjQ3ZDkzZjNkMmQ2NTg5ZTNkMGY4MGM3MGIz
-    NjI4MzBmMTczOGEzYmYxOTQyZTQzN2EyNTJhZWY4ODZjMWVhODAzOTVlMTU2
-    NDI1ZjRjOWYyZjg1YzcyMjkyNmMzMTEwOGY4YmFmMzY1NGM3OWM=
+    MGQwYTNkYzcyNjk2OGU3YWMzODliODEyMWY0MzQ4ZTE0MGIyOGRkOTc5MzUx
+    ZjU1OTA4ZGRkOWNiNTc0ZDNhNjYxMTBjNDUyZmRhMThkNzQ4NWY1NTc4Y2Ey
+    NTgwZTU4OTk2NDMwOGQyN2I4MTVmMGFkYzBjNmM5NTUxZjg2ZTg=

data/README.md

@@ -1,14 +1,15 @@
 # Mongoid Listable
-[![Code Climate](https://codeclimate.com/repos/527c1e427e00a44bc100c7e3/badges/344ff1980ca523c67291/gpa.png)](https://codeclimate.com/repos/527c1e427e00a44bc100c7e3/feed)
+[![Code Climate](https://codeclimate.com/github/richardcalahan/mongoid_listable.png)](https://codeclimate.com/github/richardcalahan/mongoid_listable)
 [![Build Status](https://travis-ci.org/richardcalahan/mongoid_listable.png?branch=master)](https://travis-ci.org/richardcalahan/mongoid_listable)
 [![Coverage Status](https://coveralls.io/repos/richardcalahan/mongoid_listable/badge.png?branch=master)](https://coveralls.io/r/richardcalahan/mongoid_listable?branch=master)
 [![Gem Version](https://badge.fury.io/rb/mongoid_listable.png)](http://badge.fury.io/rb/mongoid_listable)
 
-Mongoid Listable manages lists for isolated collections or for more complex `has_many` / `belongs_to` relationships.
+Mongoid Listable is a library for managing listable relations. It works great for isolated collections or for more complex `has_many` / `embeds_many` relationships.
+
 There are two main macros:   
 
-`listed` for isolated lists not belonging to any parent object.   
-`lists`  for `has_many` / `belongs_to` relationships
+* `listed` for non-relational lists that do not belong to any objects.   
+* `lists`  for `has_many` / `embeds_many` relationships.
 
 
 ## Basic Usage - Isolated
@@ -20,11 +21,23 @@ There are two main macros:
       listed
     end
     
-The `listed` macro will assign a `position` field and a `list` scope to the Photo class. All Photo instances 
-added or removed, (or whose position fields are updated) will trigger automatic reording of all sibling instances.
-    
+The `listed` macro will assign a `position` field and a `list` scope to the Photo class. All Photo instances that are
+created, destroyed, or have their position field updated will trigger a reording of all sibling instances. 
+
+Non-relational lists can have as many listed contexts as needed. You'll need to specify both the `scope` and the
+`field` options in these cases.
+
+    class Photo
+
+      include Mongoid::Document
+      include Mongoid::Listable
+
+      listed :scope :list, field: :position
+      listed :scope :slideshow, field: :slideshow_position
+
+    end
     
-## Basic Usage - Has Many
+## Basic Usage - Has Many / Embeds Many
 
 
     class User
@@ -32,6 +45,8 @@ added or removed, (or whose position fields are updated) will trigger automatic
       include Mongoid:Listable
     
       has_many :photos
+      # or embeds_many :photos
+      
       lists :photos
       ...
     end
@@ -40,11 +55,12 @@ added or removed, (or whose position fields are updated) will trigger automatic
       include Mongoid::Document
       
       belongs_to :user
+      # or embedded_in :user
       ...
     end
     
-In this example photos that are added to or removed from a user, or have their position attribute updated
-will maintain logical order based on the method used:
+In this example photos that are added to or removed from a user's collection, or have their position attribute updated
+will trigger a reordering of all sibling instances. For example:
 
     # setter
     User.first.photos = [ photo_a, photo_c, photo_b ]
@@ -61,13 +77,14 @@ will maintain logical order based on the method used:
     
     
 
-Each photo that belongs to the user will automatically obtain a field called `user_position`. The field
-is derived from the foreign key of the relation, replacing "\_id" with "_position".
+Each photo that belongs to the user will automatically obtain a field called `user_position`. The field name
+is derived from the foreign key of the relation, replacing "\_id" with "_position". Having a unique position key
+for each 1-n relationship allows for more complex lists.  
 
-The `has_many` relation of a user to their photos will automatically be ordered by `user_position` unless otherwise specified
+The `has_many` / `embeds_many` relationship of a user to their photos will automadtically be ordered by `user_position` unless otherwise specified
 via the standard `order` option to the `has_many` macro. 
     
-## Advanced Usage - Has Many
+## Advanced Usage - Has Many / Embeds Many
 
     # Handles multiple has_many relations on same model!
     
@@ -110,10 +127,6 @@ In this example, there are two `has_many` relations defined between a user and p
 obtain two position fields: `featured_by_user_position` and `kodaked_by_user_position`.
 
 
-## Todo
-
-Need to test embedded documents.
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/mongoid/listable/accessors.rb

@@ -21,7 +21,6 @@ module Mongoid
           redefine_method ids_method do |ids|            
             send meta.setter, meta.klass.find(ids).sort_by_attr(:id, ids)
           end
-
           self
         end
 
@@ -37,14 +36,13 @@ module Mongoid
         def set name, meta
           before_method "#{name}=" do |objects|
             objects ||= []
-
-            reposition objects, field_name(meta), 1
+            
+            reposition objects, position_field_name(meta), 1
 
             (send(name).to_a - objects).each do |object|
-              object.unset field_name(meta)
+              object.unset position_field_name(meta)
             end
           end
-
           self
         end
 

data/lib/mongoid/listable/callbacks.rb

@@ -9,25 +9,20 @@ module Mongoid
         # Defines a mongoid before_create callback.
         # Sets the position field to current object count + 1
         #
-        # @param [ Hash ] The configuration hash
+        # @param [ Symbol ] The name of the position field
         #
         # @return [ Object ] self
         #
         # @since 0.1.0
         def created name
-          callback = "#{name}_#{__method__}"
-          define_method callback do
-            position = send(name)
-            if position.present?
-              siblings = siblings name
-              reposition siblings.gte(name => position), name, position + 1
+          register_callback name, :before_create do
+            if position = send(name)
+              objects = siblings(name).gte(name => position)
+              reposition objects, name, position + 1
             else
               set name, siblings(name).count + 1
             end
           end
-
-          before_create callback
-          self
         end
 
         # Defines a mongoid before_update callback.        
@@ -35,41 +30,33 @@ module Mongoid
         # Hoe the change is applied varies depending on the redrection
         # of the update.
         #
-        # @param [ Hash ] The configuration hash
+        # @param [ Symbol ] The name of the position field
         #
         # @return [ Object ] self
         #
         # @since 0.1.0
         def updated name
-          callback = "#{name}_#{__method__}"
-          define_method callback do       
+          register_callback name, :before_update do
             apply_change_on name if send("#{name}_changed?")
           end
-          before_update callback
-          self
         end
 
         # Defines a mongoid before_destroy callback.        
         # Resets all sibling object's higher in the list
         #
-        # @param [ Hash ] The configuration hash
+        # @param [ Symbol ] The name of the position field
         #
         # @return [ Object ] self
         #
         # @since 0.1.0
         def destroyed name
-          callback = "#{name}_#{__method__}"
-          define_method callback do
-            position = send name
-            siblings = siblings(name).gt(name => position)
-            reposition siblings, name, position
+          register_callback name, :before_destroy do
+            siblings = siblings(name).gt(name => send(name))
+            reposition siblings, name, send(name)
           end
-
-          before_destroy callback
-          self
         end
 
-        # Defines a mongoid has_many relation after_add callback.
+        # Defines a mongoid 1-n relation after_add callback.
         # Sets the position attribute to current relations length + 1
         #
         # @param [ Symbol ]   name The name of the has_many relation
@@ -79,22 +66,19 @@ module Mongoid
         #
         # @since 0.0.6
         def added name, meta
-          callback = "#{name.to_s.singularize}_added"
-          define_method callback do |object|
+          register_callback name, :after_add do |object|
             return unless object.new_record?
-            field_name = field_name(meta)
+            field_name = position_field_name meta
             if position = object.send(field_name) 
               objects = object.siblings(field_name).gte(field_name => position)
               reposition objects, field_name, position + 1
             else                       
-              object.set field_name, has_many_count(name)
+              object.set field_name, many(name).count
             end
           end
-          meta[:after_add] = callback
-          self
         end
 
-        # Defines a mongoid has_many relation before_remove callback.
+        # Defines a mongoid 1-n relation before_remove callback.
         # Resets the position index on all objects that came after
         #
         # @param [ Symbol ]   name The name of the has_many relation
@@ -103,17 +87,25 @@ module Mongoid
         # @return [ Object ] self
         #
         # @since 0.0.6
-        def removed name, meta       
-          field_name = field_name meta
-          callback   = "#{name.to_s.singularize}_removed"
-          define_method callback do |object|
-            position = object.send field_name
-            reposition object.siblings(field_name).gt(field_name => position), 
-            field_name, position
-            object.unset field_name
+        def removed name, meta                
+          register_callback name, :before_remove do |object|
+            field_name = position_field_name meta
+            objects    = object.siblings(field_name)
+              .gt(field_name => object.send(field_name))
+            reposition objects, field_name, object.send(field_name)
+            object.unset field_name            
           end
+        end
+
+        private
+
+        def register_callback name, hook, &block
+          meta     = reflect_on_association name
+          callback = "#{hook}_#{name}" 
+
+          define_method callback, &block
 
-          meta[:after_remove] = callback
+          meta ? meta[hook] = callback : send(hook, callback) 
           self
         end
 
@@ -121,19 +113,18 @@ module Mongoid
 
       private
 
-      # Applies a position change on column. Which objects are repositioned
+      # Applies a position change on field. Which objects are repositioned
       # depends on the direction of the change.
       #
-      # @param [ Symbol ] name The name of position column
+      # @param [ Symbol ] name The name of position field
       #
       # @since 0.1.0
       def apply_change_on name
         from, to = change_on name
-        siblings = siblings name
         if to > from
-          reposition siblings.between(name => from..to), name, from
+          reposition siblings(name).between(name => from..to), name, from
         elsif to < from       
-          reposition siblings.between(name => to..from), name, to + 1
+          reposition siblings(name).between(name => to..from), name, to + 1
         end
         set name, to
       end

data/lib/mongoid/listable/macros.rb

@@ -15,14 +15,22 @@ module Mongoid
         # @return self
         #
         # @since 0.1.0
-        def listed
-          field :position, type: Integer
+        def listed options={}
+          config = { 
+            field: :position,
+            scope: :list 
+          }
 
-          created(:position)
-            .updated(:position)
-            .destroyed(:position)
+          config.merge! options
+
+          field config[:field], type: Integer
+
+          created   config[:field]
+          updated   config[:field]
+          destroyed config[:field]
+
+          scope config[:scope], order_by(config[:field] => :asc)
 
-          scope :list, order_by(:position => :asc)
           self
         end
 
@@ -34,19 +42,21 @@ module Mongoid
         # @return [ Mongoid:Relations:Metadata ] Instance of metadata
         #
         # @since 0.0.1
-        def lists name, options={}
-          meta = reflect_on_association name
+        def lists association, options={}
+          meta       = reflect_on_association association
+          field_name = determine_position_field_name meta
 
-          field_name = field_name(meta)
           meta.klass.send :field, field_name, type: Integer
 
-          ids_set(name, meta).set(name, meta)
-            .added(name, meta).removed(name, meta)
+          ids_set association, meta
+          set     association, meta
+          added   association, meta
+          removed association, meta
 
           meta.klass.send :include, Mongoid::Listable
           meta.klass.updated(field_name).destroyed(field_name)
 
-          meta[:order] ||= "#{field_name(meta)} asc"
+          meta[:order] ||= "#{field_name} asc"
         end
 
       end

data/lib/mongoid/listable/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Listable
-    VERSION = '0.2.1'
+    VERSION = '0.2.3'
   end
 end

data/lib/mongoid/listable.rb

@@ -13,43 +13,29 @@ module Mongoid
       include Mongoid::Listable::Macros
     end
 
-    module ClassMethods
-
-      # Generates the position field name using the MetaData class
-      #
-      # @param [ MetaData ] meta The MetaData class
-      #
-      # @return Symbol
-      #
-      # @since 0.0.6
-      def field_name meta
-        (meta.foreign_key.to_s.gsub(/_?id$/, '_position')).to_sym
-      end
-
-    end
-
-    # Proxies to the class level version
+    # Proxies to the class level determine_position_field_name
     #
     # @param [ MetaData ] meta The MetaData class
     # @see Class.field_name
     #
     # @since 0.0.6
-    def field_name meta
-      self.class.field_name meta
+    def position_field_name meta
+      self.class.determine_position_field_name meta
     end
 
-    # Counts unique children of object
+    # Finds unique instances of objects for a given relation
     # Needed because the mongoid callbacks dont update
     # has_many relations until after invoked.
     #
     # @param [ Symbol ]   name The name of the has_many relation
     #
-    # @since 0.0.7
-    def has_many_count name
-      send(name).uniq(&:id).count
+    # @since 0.2.1
+    def many name
+      send(name).uniq(&:id)
     end
 
-    # Retrieves an object's list siblings
+    # Retrieves siblings of an object in a list. 
+    # Scoped by the position fiels name
     #
     # @return [ Array ]
     #
@@ -61,18 +47,33 @@ module Mongoid
 
     private
 
-    # Resets column on objects starting at 'start'
+    # Resets position field on objects starting at 'start'
     #
     # @param [ Array ] objects The objects to interate
-    # @param [ Symbol ] column The column to update
+    # @param [ Symbol ] column The field to update
     # @param [ Integer ] start The starting position
     #
     # @since 0.1.0
-    def reposition objects, column, start
+    def reposition objects, field, start
       objects.each_with_index do |object, index|
-        object.set column, start + index
+        object.set field, start + index
       end
     end
 
+    module ClassMethods
+
+      # Generates the position field name using the MetaData instance
+      #
+      # @param [ MetaData ] meta The MetaData instance
+      #
+      # @return Symbol
+      #
+      # @since 0.2.1
+      def determine_position_field_name meta
+        (meta.foreign_key.to_s.gsub(/_?id$/, '_position')).to_sym
+      end
+
+    end
+
   end
 end

data/spec/models/item.rb

@@ -3,6 +3,6 @@ class Item
   include Mongoid::Document
   include Mongoid::Listable
 
-  listed
+  listed field: :custom_field, scope: :custom_scope
 
 end

data/spec/mongoid_listable_spec.rb

@@ -10,90 +10,93 @@ describe Mongoid::Listable do
 
   describe 'listed' do 
 
+    FIELD = :custom_field
+    SCOPE = :custom_scope
+
     before :each do
       Item.destroy_all
       10.times { Item.create! }
-    end
+    end    
 
     after :each do 
-      ensure_order Item.list, :position
+      ensure_order Item.send(SCOPE), FIELD
     end
 
     it 'should have a position field' do 
-      expect(Item.fields.key?('position')).to be_true
+      expect(Item.fields.key?(FIELD.to_s)).to be_true
     end
 
     it 'should have a list scope' do 
-      expect(Item.scopes.key?(:list)).to be_true
+      expect(Item.scopes.key?(SCOPE)).to be_true
     end
 
     it 'should append new object at position 1' do
-      item = Item.create position: 1
-      expect(item.position).to eq(1)
+      item = Item.create FIELD => 1
+      expect(item.send(FIELD)).to eq(1)
     end
 
     it 'should append new object at position 5' do
-      item = Item.create position: 5
-      expect(item.position).to eq(5)
+      item = Item.create FIELD => 5
+      expect(item.send(FIELD)).to eq(5)
     end
 
     it 'should append new object at end of list' do
       item = Item.create
-      expect(item.position).to eq(11)
+      expect(item.send(FIELD)).to eq(11)
     end
 
     it 'should maintain order when removing object at position 1' do
-      Item.list.first.destroy
+      Item.send(SCOPE).first.destroy
     end
 
     it 'should maintain order when removing object at position 5' do
-      Item.where(position: 5).destroy
+      Item.where(FIELD => 5).destroy
     end
 
     it 'should maintain order when removing object at position 10' do
-      Item.list.last.destroy
+      Item.send(SCOPE).last.destroy
     end
 
     it 'should maintain order when moving object from position 1 to 5' do
-      item = Item.list.first
-      item.update_attribute :position, 5
-      expect(Item.list.where(position: 5).first).to eq(item)
+      item = Item.send(SCOPE).first
+      item.update_attribute FIELD, 5
+      expect(Item.send(SCOPE).where(FIELD => 5).first).to eq(item)
     end
 
     it 'should maintain order when moving object from position 10 to 5' do
-      item = Item.list.last
-      item.update_attribute :position, 5
-      expect(Item.list.where(position: 5).first).to eq(item)
+      item = Item.send(SCOPE).last
+      item.update_attribute FIELD, 5
+      expect(Item.send(SCOPE).where(FIELD => 5).first).to eq(item)
     end
 
     it 'should maintain order when moving object from position 2 to 6' do
-      item = Item.list.where(position: 2).first
-      item.update_attribute :position, 6
-      expect(Item.list.where(position: 6).first).to eq(item)
+      item = Item.send(SCOPE).where(FIELD => 2).first
+      item.update_attribute FIELD, 6
+      expect(Item.send(SCOPE).where(FIELD => 6).first).to eq(item)
     end
 
     it 'should maintain order when moving object from position 8 to 4' do
-      item = Item.list.where(position: 8).first
-      item.update_attribute :position, 4
-      expect(Item.list.where(position: 4).first).to eq(item)
+      item = Item.send(SCOPE).where(FIELD => 8).first
+      item.update_attribute FIELD, 4
+      expect(Item.send(SCOPE).where(FIELD => 4).first).to eq(item)
     end
 
     it 'should do nothing when assigning object to same position' do
-      item = Item.list.where(position: 5).first
-      item.update_attribute :position, 5
-      expect(Item.list.where(position: 5).first).to eq(item)
+      item = Item.send(SCOPE).where(FIELD => 5).first
+      item.update_attribute FIELD, 5
+      expect(Item.send(SCOPE).where(FIELD => 5).first).to eq(item)
     end
 
     it 'should compensate for updated positions that are higher than bounds' do
-      item = Item.list.where(position: 5).first
-      item.update_attribute :position, 100
-      expect(Item.list.last).to eq(item)
+      item = Item.send(SCOPE).where(FIELD => 5).first
+      item.update_attribute FIELD, 100
+      expect(Item.send(SCOPE).last).to eq(item)
     end
 
     it 'should compensate for updated positions that are lower than bounds' do
-      item = Item.list.where(position: 5).first
-      item.update_attribute :position, -100
-      expect(Item.list.first).to eq(item)
+      item = Item.send(SCOPE).where(FIELD => 5).first
+      item.update_attribute FIELD, -100
+      expect(Item.send(SCOPE).first).to eq(item)
     end
 
   end
@@ -145,6 +148,11 @@ describe Mongoid::Listable do
         Article.first.sections.first.destroy        
       end
 
+      it 'should maintain order when removing object at position 2' do
+        section = Article.first.sections.where(article_position: 2).first
+        Article.first.sections.delete(section)
+      end
+
       it 'should maintain order when removing object at position 5' do
         Article.first.sections.where(article_position: 5).first.destroy
       end
@@ -258,6 +266,11 @@ describe Mongoid::Listable do
         User.first.photos.first.destroy        
       end
 
+      it 'should maintain order when removing object at position 2' do
+        photo = User.first.photos.where(user_position: 2).first
+        User.first.photos.delete(photo)
+      end
+
       it 'should maintain order when removing object at position 5' do
         User.first.photos.where(user_position: 5).first.destroy
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_listable
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - richardcalahan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-11 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid