Class: Activr::Timeline::Route

Inherits:
Object
  • Object
show all
Defined in:
lib/activr/timeline/route.rb

Overview

A timeline route describes how an activity is routed to a timeline

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(timeline_class, activity_class, settings) ⇒ Route

Returns a new instance of Route.

Parameters:

  • timeline_class (Class) —

    Timeline class

  • activity_class (Class) —

    Activity class

  • settings (Hash) —

    Route settings

Options Hash (settings):

  • :using (Symbol) —

    Predefined routing kind

  • :to (Symbol) —

    Routing path

  • :kind (Symbol) —

    Manually specified routing kind



36
37
38
39
40
 
# File 'lib/activr/timeline/route.rb', line 36

def initialize(timeline_class, activity_class, settings)
  @timeline_class = timeline_class
  @activity_class = activity_class
  @settings       = settings
end

Instance Attribute Details

#activity_class ⇒ Class (readonly)

Returns activity class.

Returns:

  • (Class) —

    activity class



10
11
12
 
# File 'lib/activr/timeline/route.rb', line 10

def activity_class
  @activity_class
end

#settings ⇒ Hash (readonly)

Returns route settings.

Returns:

  • (Hash) —

    route settings



13
14
15
 
# File 'lib/activr/timeline/route.rb', line 13

def settings
  @settings
end

#timeline_class ⇒ Class (readonly)

Returns timeline class.

Returns:

  • (Class) —

    timeline class



7
8
9
 
# File 'lib/activr/timeline/route.rb', line 7

def timeline_class
  @timeline_class
end

Class Method Details

.kind_for_routing_and_activity(routing_kind, activity_kind) ⇒ String

Get route kind

Parameters:

  • routing_kind (String) —

    Routing kind

  • activity_kind (String) —

    Activity kind

Returns:

  • (String) —

    Route kind



23
24
25
 
# File 'lib/activr/timeline/route.rb', line 23

def kind_for_routing_and_activity(routing_kind, activity_kind)
  "#{routing_kind}_#{activity_kind}"
end

Instance Method Details

#apply_meth(receiver, meth, activity) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Apply a method on receiver, with given activity as parameter if receiver arity permits it

Parameters:

  • receiver (Object) —

    Receiver

  • meth (Symbol) —

    Method to call

  • activity (Activity) —

    Activity to provide in method call

Returns:

  • (Object) —

    Result of method call on receiver



150
151
152
153
154
155
156
157
158
159
 
# File 'lib/activr/timeline/route.rb', line 150

def apply_meth(receiver, meth, activity)
  case receiver.method(meth).arity
  when 2
    receiver.__send__(meth, activity, self.timeline_class)
  when 1
    receiver.__send__(meth, activity)
  else
    receiver.__send__(meth)
  end
end

#kind ⇒ String

Get route kind

Returns:

  • (String) —

    Route kind



45
46
47
 
# File 'lib/activr/timeline/route.rb', line 45

def kind
  @kind ||= self.class.kind_for_routing_and_activity(self.routing_kind, self.activity_class.kind)
end

#resolve(activity) ⇒ Array<Object>

Resolve recipients for given activity

Parameters:

  • activity (Activity) —

    Activity to resolve

Returns:

  • (Array<Object>) —

    Array of recipients instances and/or ids



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/activr/timeline/route.rb', line 79

def resolve(activity)
  recipients = if self.settings[:using]
    self.resolve_using_method(self.settings[:using], activity)
  elsif self.settings[:to]
    self.resolve_to_path(self.settings[:to], activity)
  else
    raise "Don't know how to resolve recipients: #{self.settings}"
  end

  recipients = [ recipients ] unless recipients.is_a?(Array)
  recipients.compact!

  # check recipients
  bad_recipient = recipients.find{ |recipient| !self.timeline_class.valid_recipient?(recipient) }
  if bad_recipient
    raise "Invalid recipient resolved by route #{self.inspect}: #{bad_recipient.inspect}"
  end

  recipients
end

#resolve_to_path(path, activity) ⇒ Array<Object>

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Resolve route using path

Parameters:

  • path (String) —

    Path on activity

  • activity (Activity) —

    Activity to resolve

Returns:

  • (Array<Object>) —

    Array of recipients instances and/or ids



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/activr/timeline/route.rb', line 119

def resolve_to_path(path, activity)
  receivers = [ activity ]

  meth_ary = path.to_s.split('.')
  meth_ary.map(&:to_sym).each do |meth|
    receivers = receivers.map do |receiver|
      if !receiver.respond_to?(meth)
        raise "Can't resolve routing path: receiver does not respond to method '#{meth}': #{receiver.inspect}"
      end

      # send method
      self.apply_meth(receiver, meth, activity)
    end.flatten.compact
  end

  receivers
end

#resolve_using_method(meth, activity) ⇒ Array<Object>

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Resolve route using method call

Parameters:

  • meth (Symbol) —

    Method to call on timeline class

  • activity (Activity) —

    Activity to resolve

Returns:

  • (Array<Object>) —

    Array of recipients instances and/or ids



107
108
109
110
 
# File 'lib/activr/timeline/route.rb', line 107

def resolve_using_method(meth, activity)
  # send method
  self.apply_meth(self.timeline_class, meth, activity)
end

#routing_kind ⇒ String

Get routing kind

Returns:

  • (String) —

    Routing kind



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/activr/timeline/route.rb', line 52

def routing_kind
  @routing_kind ||= (self.settings[:kind] && self.settings[:kind].to_s) || begin
    if self.settings[:using] && self.settings[:to]
      raise "Several routing kinds specified for #{self.activity_class}: #{self.settings.inspect}"
    end

    if self.settings[:using].blank? && self.settings[:to].blank?
      raise "Missing routing for #{self.activity_class}: #{self.settings.inspect}"
    end

    result = self.settings[:using]
    if result.blank?
      result = if self.settings[:to].is_a?(Symbol)
        self.settings[:to]
      else
        self.settings[:to].to_s.underscore.gsub('.', '_').to_sym
      end
    end

    result.to_s
  end
end