lib/markable/acts_as_markable.rb in markable-0.1.3 vs lib/markable/acts_as_markable.rb in markable-0.1.4

@@ -4,81 +4,90 @@
 
     module ClassMethods
       def markable_as(*args)
         options = args.extract_options!
         marks   = args.flatten
+        by      = options[:by]
 
         Markable.set_models
 
         class_eval do
           class << self
             attr_accessor :__markable_marks
           end
         end
 
-        marks = Array.wrap(marks).map!{|i| i.to_sym }
+        marks = Array.wrap(marks).map!(&:to_sym)
 
-        markers = options[:by].present? ? Array.wrap(options[:by]) : :all
+        markers = by.present? ? Array.wrap(by) : :all
 
         self.__markable_marks ||= {}
         marks.each do |mark|
           self.__markable_marks[mark] = {
             :allowed_markers => markers
           }
         end
 
         class_eval do
-          has_many :markable_marks, :class_name => 'Markable::Mark', :as => :markable, :dependent => :delete_all
+          has_many :markable_marks,
+                   :class_name => 'Markable::Mark',
+                   :as => :markable,
+                   :dependent => :delete_all
           include Markable::ActsAsMarkable::MarkableInstanceMethods
 
           def self.marked_as(mark, options = {})
-            if options[:by].present?
-              result = self.joins(:markable_marks).where( :marks => {
-                :mark => mark.to_s, :marker_id => options[:by].id, :marker_type => options[:by].class.name
+            by = options[:by]
+            if by.present?
+              result = self.joins(:markable_marks).where({
+                :marks => {
+                  :mark => mark.to_s,
+                  :marker_id => by.id,
+                  :marker_type => by.class.name
+                }
               })
               markable = self
               result.class_eval do
                 define_method :<< do |object|
-                  options[:by].set_mark mark, object
+                  by.set_mark(mark, object)
                   self
                 end
                 define_method :delete do |markable|
-                  options[:by].remove_mark mark, markable
+                  by.remove_mark(mark, markable)
                   self
                 end
               end
             else
-              result = self.joins(:markable_marks).where( :marks => { :mark => mark.to_s } ).group("#{self.table_name}.id")
+              result = self.joins(:markable_marks).where(:marks => { :mark => mark.to_s }).group("#{self.table_name}.id")
             end
             result
           end
         end
 
         self.__markable_marks.each do |mark, o|
           class_eval %(
-            def self.marked_as_#{mark} options = {}
-              self.marked_as :#{mark}, options
+            def self.marked_as_#{mark}(options = {})
+              self.marked_as(:#{mark}, options)
             end
 
-            def marked_as_#{mark}? options = {}
-              self.marked_as? :#{mark}, options
+            def marked_as_#{mark}?(options = {})
+              self.marked_as?(:#{mark}, options)
             end
           )
         end
 
-        Markable.add_markable self
+        Markable.add_markable(self)
       end
     end
 
     module MarkableInstanceMethods
 
       def method_missing(method_sym, *args)
         Markable.models.each do |model_name|
           if method_sym.to_s =~ Regexp.new("^#{model_name.downcase.pluralize}_have_marked_as(_[\\w_]+)?$")
             model_name.constantize # ping model
 
-            if self.methods.include? method_sym # method has appear
+            if self.methods.include?(method_sym) # method has appear
               return self.method(method_sym).call(*args) # call this method
             end
           end
         end
         super
@@ -86,83 +95,85 @@
         super
       end
 
       def mark_as(mark, markers)
         Array.wrap(markers).each do |marker|
-          Markable.can_mark_or_raise? marker, self, mark
+          Markable.can_mark_or_raise?(marker, self, mark)
           params = {
             :markable_id => self.id,
             :markable_type => self.class.name,
             :marker_id => marker.id,
             :marker_type => marker.class.name,
             :mark => mark.to_s
           }
-          Markable::Mark.create(params) unless Markable::Mark.exists? params
+          Markable::Mark.create(params) unless Markable::Mark.exists?(params)
         end
       end
 
       def marked_as?(mark, options = {})
-        if options[:by].present?
-          Markable.can_mark_or_raise? options[:by], self, mark
-        end
+        by = options[:by]
         params = {
           :markable_id => self.id,
           :markable_type => self.class.name,
           :mark => mark.to_s
         }
-        if options[:by].present?
-          params[:marker_id] = options[:by].id
-          params[:marker_type] = options[:by].class.name
+        if by.present?
+          Markable.can_mark_or_raise?(by, self, mark)
+          params[:marker_id] = by.id
+          params[:marker_type] = by.class.name
         end
-        Markable::Mark.exists? params
+        Markable::Mark.exists?(params)
       end
 
       def unmark(mark, options = {})
-        if options[:by].present?
-          Markable.can_mark_or_raise? options[:by], self, mark
-          Array.wrap(options[:by]).each do |marker|
-            params = {
+        by = options[:by]
+        if by.present?
+          Markable.can_mark_or_raise?(by, self, mark)
+          Array.wrap(by).each do |marker|
+            Markable::Mark.delete_all({
               :markable_id => self.id,
               :markable_type => self.class.name,
               :marker_id => marker.id,
               :marker_type => marker.class.name,
               :mark => mark.to_s
-            }
-            Markable::Mark.delete_all(params)
+            })
           end
         else
-          params = {
+          Markable::Mark.delete_all({
             :markable_id => self.id,
             :markable_type => self.class.name,
             :mark => mark.to_s
-          }
-          Markable::Mark.delete_all(params)
+          })
         end
       end
 
       def have_marked_as_by(mark, target)
-        result = target.joins(:marker_marks).where( :marks => {
-          :mark => mark.to_s, :markable_id => self.id, :markable_type => self.class.name
+        result = target.joins(:marker_marks).where({
+          :marks => {
+            :mark => mark.to_s,
+            :markable_id => self.id,
+            :markable_type => self.class.name
+          }
         })
         markable = self
         result.class_eval do
           define_method :<< do |markers|
             Array.wrap(markers).each do |marker|
-              marker.set_mark mark, markable
+              marker.set_mark(mark, markable)
             end
             self
           end
           define_method :delete do |markers|
-            Markable.can_mark_or_raise? markers, markable, mark
+            Markable.can_mark_or_raise?(markers, markable, mark)
             Array.wrap(markers).each do |marker|
-              marker.remove_mark mark, markable
+              marker.remove_mark(mark, markable)
             end
             self
           end
         end
         result
       end
     end
   end
 end
 
-ActiveRecord::Base.send :include, Markable::ActsAsMarkable
+ActiveRecord::Base.send(:include, Markable::ActsAsMarkable)