Module: ActsAsFollower::Follower::InstanceMethods

Defined in:
lib/acts_as_follower/follower.rb

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args) ⇒ Object

Allows magic names on following_by_type e.g. following_users == following_by_type(‘User’) Allows magic names on following_by_type_count e.g. following_users_count == following_by_type_count(‘User’)



91
92
93
94
95
96
97
98
99
 
# File 'lib/acts_as_follower/follower.rb', line 91

def method_missing(m, *args)
  if m.to_s[/following_(.+)_count/]
    following_by_type_count($1.singularize.classify)
  elsif m.to_s[/following_(.+)/]
    following_by_type($1.singularize.classify)
  else
    super
  end
end

Instance Method Details

#all_following(options = {}) ⇒ Object

Returns the actual records which this instance is following.



62
63
64
 
# File 'lib/acts_as_follower/follower.rb', line 62

def all_following(options={})
  all_follows(options).collect{ |f| f.followable }
end

#all_follows(options = {}) ⇒ Object

Returns the follow records related to this instance with the followable included.



56
57
58
59
 
# File 'lib/acts_as_follower/follower.rb', line 56

def all_follows(options={})
  follows_scope = follows_scoped
  follows_scope = apply_options_to_scope(follows_scope, options)
end

#follow(followable) ⇒ Object

Creates a new follow record for this instance to follow the passed object. Does not allow duplicate records to be created.



30
31
32
33
34
35
 
# File 'lib/acts_as_follower/follower.rb', line 30

def follow(followable)
  if self != followable
    params = {followable_id: followable.id, followable_type: parent_class_name(followable)}
    self.follows.where(params).first_or_create!
  end
end

#follow_count ⇒ Object

Returns the number of objects this instance is following.



24
25
26
 
# File 'lib/acts_as_follower/follower.rb', line 24

def follow_count
  Follow.unblocked.for_follower(self).count
end

#following?(followable) ⇒ Boolean

Returns true if this instance is following the object passed as an argument.

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/acts_as_follower/follower.rb', line 19

def following?(followable)
  0 < Follow.unblocked.for_follower(self).for_followable(followable).count
end

#following_by_type(followable_type, options = {}) ⇒ Object

Returns the actual records of a particular type which this record is following.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/acts_as_follower/follower.rb', line 67

def following_by_type(followable_type, options={})
  followables = followable_type.constantize.
    joins(:followings).
    where('follows.blocked'         => false,
          'follows.follower_id'     => self.id,
          'follows.follower_type'   => parent_class_name(self),
          'follows.followable_type' => followable_type)
  if options.has_key?(:limit)
    followables = followables.limit(options[:limit])
  end
  if options.has_key?(:includes)
    followables = followables.includes(options[:includes])
  end
  followables
end

#following_by_type_count(followable_type) ⇒ Object 



83
84
85
 
# File 'lib/acts_as_follower/follower.rb', line 83

def following_by_type_count(followable_type)
  follows.unblocked.for_followable_type(followable_type).count
end

#follows_by_type(followable_type, options = {}) ⇒ Object

Returns the follow records related to this instance by type.



50
51
52
53
 
# File 'lib/acts_as_follower/follower.rb', line 50

def follows_by_type(followable_type, options={})
  follows_scope  = follows_scoped.for_followable_type(followable_type)
  follows_scope = apply_options_to_scope(follows_scope, options)
end

#follows_scoped ⇒ Object

returns the follows records to the current instance



45
46
47
 
# File 'lib/acts_as_follower/follower.rb', line 45

def follows_scoped
  self.follows.unblocked.includes(:followable)
end

#get_follow(followable) ⇒ Object

Returns a follow record for the current instance and followable object.



106
107
108
 
# File 'lib/acts_as_follower/follower.rb', line 106

def get_follow(followable)
  self.follows.unblocked.for_followable(followable).first
end

#respond_to?(m, include_private = false) ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
 
# File 'lib/acts_as_follower/follower.rb', line 101

def respond_to?(m, include_private = false)
  super || m.to_s[/following_(.+)_count/] || m.to_s[/following_(.+)/]
end

#stop_following(followable) ⇒ Object

Deletes the follow record if it exists.



38
39
40
41
42
 
# File 'lib/acts_as_follower/follower.rb', line 38

def stop_following(followable)
  if follow = get_follow(followable)
    follow.destroy
  end
end