card 1.17.4 → 1.18.0

data/mod/05_email/set/self/created.rb

@@ -1,21 +1,19 @@
 include Card::FollowOption
 
-self.restrictive_follow_opts position: 1
+restrictive_follow_opts position: 1
 
-self.follower_candidate_ids do |card|
-  [ card.creator_id ]
+follower_candidate_ids do |card|
+  [card.creator_id]
 end
 
-
 def title
   'Following content you created'
 end
 
 def label
-  "follow if I created"
+  'follow if I created'
 end
 
 def description set_card
   "#{set_card.follow_label} I created"
 end
-

data/mod/05_email/set/self/edited.rb

@@ -1,24 +1,20 @@
 include Card::FollowOption
 
-self.restrictive_follow_opts position: 2
+restrictive_follow_opts position: 2
 
-self.follower_candidate_ids do |card|
+follower_candidate_ids do |card|
   # FIXME? - could optimize by not using cards table...
   Card.search editor_of: card.name, return: :id
 end
 
-
 def title
   'Following content you edited'
 end
 
 def label
-  "follow if I edited"
+  'follow if I edited'
 end
 
 def description set_card
   "#{set_card.follow_label} I edited"
 end
-
-
-

data/mod/05_email/set/self/follow_defaults.rb

@@ -1,5 +1,5 @@
-event :update_follow_rules,
-      after: :store, on: :save, when: proc { |c| c.update_all_users } do
+event :update_follow_rules, :finalize,
+      on: :save, when: proc { |c| c.update_all_users } do
   defaults = item_names.map do |item|
     if (set_card = Card.fetch item.to_name.left) && set_card.type_code == :set
       option_card = Card.fetch(item.to_name.right) ||
@@ -18,12 +18,11 @@ event :update_follow_rules,
     Card.search(type: 'user').each do |user|
       defaults.each do |set_card, option|
         follow_rule = Card.fetch(set_card.follow_rule_name(user.name), new: {})
-        if follow_rule
-          follow_rule.drop_item '*never'
-          follow_rule.drop_item '*always'
-          follow_rule.add_item option
-          follow_rule.save!
-        end
+        next unless follow_rule
+        follow_rule.drop_item '*never'
+        follow_rule.drop_item '*always'
+        follow_rule.add_item option
+        follow_rule.save!
       end
     end
   end
@@ -44,11 +43,11 @@ format :html do
   view :confirm_update_all do |args|
     wrap args do
       alert 'info' do
-        %{
+        %(
           <h1>Are you sure you want to change the default follow rules?</h1>
           <p>You may choose to update all existing users.
              This may take a while. </p>
-        }
+        )
       end
     end
   end
@@ -59,11 +58,11 @@ format :html do
       success: '_self',
       card:    { update_all_users: false }
     )
-    args[:buttons] = %{
+    args[:buttons] = %(
       #{submit_button text: 'Submit and update all users',
                       disable_with: 'Updating', class: 'follow-updater'}
       #{button_tag 'Submit', class: 'follow'}
       #{cancel_button href: path(view: :edit, id: card.id)}
-    }
+    )
   end
 end

data/mod/05_email/set/self/never.rb

@@ -1,9 +1,8 @@
 include Card::FollowOption
 
-self.follow_opts position: 3
-
-self.follow_test { |follower_id, accounted_ids| false }
+follow_opts position: 3
 
+follow_test { |_follower_id, _accounted_ids| false }
 
 def title
   'Ignoring'
@@ -12,4 +11,3 @@ end
 def label
   'ignore'
 end
-

data/mod/05_email/set/type/email_template.rb

@@ -4,22 +4,21 @@ def clean_html?
 end
 
 def deliver args={}
-  begin
-    mail = format.render_mail(args)
-    mail.deliver
-  rescue Net::SMTPError => exception
-    errors.add :exception, exception.message
-  end
+  mail = format.render_mail(args)
+  mail.deliver
+rescue Net::SMTPError => exception
+  errors.add :exception, exception.message
 end
 
 def process_email_field field, config, args
   config[field] =
     if args[field]
       args[field]
-    elsif field_card = fetch(trait: field)
+    elsif (field_card = fetch(trait: field))
       # configuration can be anything visible to configurer
-      user = ( args[:follower] and Card.fetch(args[:follower]) ) || field_card.updater
-      Auth.as( user ) do
+      user = (args[:follower] && Card.fetch(args[:follower])) ||
+             field_card.updater
+      Auth.as(user) do
         yield(field_card)
       end
     else
@@ -28,10 +27,11 @@ def process_email_field field, config, args
 end
 
 def process_message_field field, config, args, format, special_args=nil
-  process_email_field( field, config, args ) do |field_card|
+  process_email_field(field, config, args) do |field_card|
     content_args = args.clone
     content_args.merge! special_args if special_args
-    field_card.contextual_content args[:context], { format: format }, content_args
+    field_card.contextual_content args[:context], { format: format },
+                                  content_args
   end
 end
 
@@ -40,31 +40,44 @@ def email_config args={}
   args[:context] ||= self
 
   [:to, :from, :cc, :bcc].each do |field_name|
-    process_email_field( field_name, config, args ) do |field_card|
-      field_card.process_email_addresses args[:context], {format: 'email_text'}, args
+    process_email_field(field_name, config, args) do |field_card|
+      field_card.process_email_addresses(
+        args[:context], { format: 'email_text' }, args
+      )
     end
   end
-  process_email_field( :attach, config, args ) do |field_card|
+  process_email_field(:attach, config, args) do |field_card|
     field_card.extended_item_contents args[:context]
   end
-  process_message_field :subject,      config, args, 'email_text', content_opts: { chunk_list: :inclusion_only }
+  process_message_field :subject, config, args, 'email_text',
+                        content_opts: { chunk_list: :nest_only }
   process_message_field :text_message, config, args, 'email_text'
   process_message_field :html_message, config, args, 'email_html'
-  config[:html_message] = Card::Mailer.layout config[:html_message] if config[:html_message].present?
-
+  if config[:html_message].present?
+    config[:html_message] = Card::Mailer.layout config[:html_message]
+  end
 
-  from_name, from_email = (config[:from] =~ /(.*)\<(.*)>/) ? [$1.strip, $2] : [nil, config[:from]]
+  from_name, from_email =
+    if config[:from] =~ /(.*)\<(.*)>/
+      [Regexp.last_match(1).strip, Regexp.last_match(2)]
+    else
+      [nil, config[:from]]
+    end
 
-  if default_from=Card::Mailer.default[:from]
-    config[:from] = from_email ? %["#{from_name || from_email}" <#{default_from}>] : default_from
+  if (default_from = Card::Mailer.default[:from])
+    config[:from] =
+      if from_email
+        %("#{from_name || from_email}" <#{default_from}>)
+      else
+        default_from
+      end
     config[:reply_to] ||= config[:from]
   elsif config[:from].blank?
     config[:from] = Card[Card::WagnBotID].account.email
   end
-  config.select {|k,v| v.present? }
+  config.select { |_k, v| v.present? }
 end
 
-
 format do
   view :mail, perms: :none do |args|
     args = card.email_config(args)
@@ -74,7 +87,7 @@ format do
     alternative = (text_message.present? && html_message.present?)
     mail = Card::Mailer.new_mail(args) do
       if alternative
-        if attachment_list and !attachment_list.empty?
+        if attachment_list && !attachment_list.empty?
           content_type 'multipart/mixed'
           part content_type: 'multipart/alternative' do |copy|
             copy.part content_type: 'text/plain' do |plain|
@@ -101,13 +114,13 @@ format do
 
       if attachment_list
         attachment_list.each_with_index do |cardname, i|
-          if (c = Card[ cardname ]) && c.respond_to?(:attachment)
-            add_file filename: "attachment-#{i + 1}.#{c.attachment.extension}", content: File.read( c.attachment.path )
+          if (c = Card[cardname]) && c.respond_to?(:attachment)
+            add_file filename: "attachment-#{i + 1}.#{c.attachment.extension}",
+                     content: File.read(c.attachment.path)
           end
         end
       end
-    end   #TODO add error handling
+    end  # TODO: add error handling
     mail
   end
-
 end

data/mod/05_email/set/type_plus_right/user/follow.rb

@@ -1,176 +1,178 @@
-
 include Card::Set::Type::Pointer
 
 def raw_content
-  @raw_content ||= if left
+  @raw_content ||=
+    if left
       items = if left.type_id == Card::UserID
-         user = left
-         follow_rules = Card.preference_cards left.name, 'follow'
-         follow_rules.map {|card| "[[#{card.name}]]" }
-      end.join "\n"
+                user = left
+                follow_rules = Card.preference_cards left.name, 'follow'
+                follow_rules.map { |card| "[[#{card.name}]]" }
+              end.join "\n"
     else
       ''
     end
 end
 
-def virtual?; !real? end
-
-
-
-format() { include Card::Set::Type::Pointer::Format   }
+def virtual?
+  !real?
+end
 
+format { include Card::Set::Type::Pointer::Format }
 
 format :html do
-   include Card::Set::Type::Pointer::HtmlFormat
+  include Card::Set::Type::Pointer::HtmlFormat
 
+  view :closed_content do |_args|
+    ''
+  end
 
-   view :closed_content do |args|
-     ''
-   end
-
-
-   view :core do |args|
-     %{
+  view :core do |args|
+    <<-HTML
       <div role="tabpanel">
-       <ul class="nav nav-tabs" role="tablist" id="myTab">
-         <li role="presentation" class="active"><a href="#following" aria-controls="following" role="tab" data-toggle="tab">Follow</a></li>
-         <li role="presentation"><a href="#ignoring" aria-controls="ignoring" role="tab" data-toggle="tab">Ignore</a></li>
-       </ul>
-
-       <div class="tab-content">
-         <div role="tabpanel" class="tab-pane active" id="following">#{render_following_list args}</div>
-         <div role="tabpanel" class="tab-pane" id="ignoring">#{render_ignoring_list}</div>
-       </div>
+        <ul class="nav nav-tabs" role="tablist" id="myTab">
+          <li role="presentation" class="active">
+             <a href="#following" aria-controls="following"
+                role="tab" data-toggle="tab">Follow</a>
+          </li>
+          <li role="presentation">
+            <a href="#ignoring" aria-controls="ignoring"
+               role="tab" data-toggle="tab">Ignore</a>
+          </li>
+        </ul>
+        <div class="tab-content">
+          <div role="tabpanel" class="tab-pane active" id="following">
+            #{render_following_list args}
+          </div>
+          <div role="tabpanel" class="tab-pane" id="ignoring">
+            #{render_ignoring_list}
+          </div>
+        </div>
       </div>
-     }
-   end
-
-
-   def followed_by_option
-     hash = Hash.new { |h,k| h[k] = [] }
-     card.item_cards.each do |follow_rule|
-       follow_rule.item_cards.each do |follow_option|
-         hash[follow_option.codename.to_sym] << follow_rule
-       end
-     end
-   end
-
-   def each_suggestion
-     if (suggestions = Card["follow suggestions"])
-       suggestions.item_names.each do |sug|
-         if ((set_card = Card.fetch sug.to_name.left) && set_card.type_code == :set)
-           option_card = Card.fetch(sug.to_name.right) || Card[sug.to_name.right.to_sym]
-           option = if option_card.follow_option?
-                      option_card.name
-                    else
-                      '*always'
-                    end
-           yield(set_card, option)
-         elsif ((set_card = Card.fetch sug) && set_card.type_code == :set)
-           yield(set_card, '*always')
-         end
-       end
-     end
-   end
-
-   # returns hashes with existing and suggested follow options
-   # structure:
-   # set_pattern_class => [ {card: rule_card, options: ['*always', '*created'] },.... ]
-   def followed_by_set
-     res = Hash.new { |h,k| h[k] = [] }
-     never = Card[:never].name
-     card.item_cards.each do |follow_rule|
-       options = follow_rule.item_names.reject { |item| item == never}
-       res[follow_rule.rule_set.subclass_for_set] << { card: follow_rule, options: options }
-     end
-
-     if Auth.signed_in? && Auth.current_id == card.left.id
-       each_suggestion do |set_card, option|
-         suggested_rule_name = set_card.follow_rule_name(card.trunk)
-         if (rule = res[set_card.subclass_for_set].find { |rule| rule[:card].name == suggested_rule_name })
-           if !rule[:options].include? option
-             rule[:options] << option
-           end
-         else
-           rule_card =  Card.new(name: suggested_rule_name)
-           res[set_card.subclass_for_set] << {card: rule_card, options: [option]}
-         end
-       end
-     end
-     res
-   end
-
-
-   view :following_list do |args|
-     if !Auth.signed_in? || Auth.current_id != card.left.id
-       hide_buttons = [:delete_follow_rule_button, :add_follow_rule_button]
-     end
-
-     sets = followed_by_set
-     wrap_with :div, class: 'pointer-list-editor' do
-       wrap_with :ul, class: 'delete-list list-group' do
-
-         Card.set_patterns.select{|p| sets[p]}.reverse.map do |set_pattern|
-           sets[set_pattern].map do |rule|
-             rule[:options].map do |option|
-
-                 content_tag :li, class: 'list-group-item' do
-                   subformat(rule[:card]).render_follow_item condition: option, hide: hide_buttons
-                 end
-
-             end.join("\n")
-           end.join("\n")
-         end.join("\n")
-
-       end
-     end
-   end
-
-
-   view :ignoring_list do |args|
-     ignore_list = []
-     card.item_cards.each do |follow_rule|
-       follow_rule.item_cards.each do |follow_option|
-         if follow_option.codename.to_sym == :never
-           ignore_list << follow_rule
-         end
-       end
-     end
-     if !Auth.signed_in? || Auth.current_id != card.left.id
-       hide_buttons = [:delete_follow_rule_button, :add_follow_rule_button]
-     end
-     never = Card[:never].name
-     wrap_with :div, class: 'pointer-list-editor' do
-       wrap_with :ul, class: 'delete-list list-group' do
-
-         ignore_list.map do |rule_card|
-           content_tag :li, class: 'list-group-item' do
-             subformat(rule_card).render_follow_item condition: never, hide: hide_buttons
-           end
-         end.join "\n"
-
-       end
-     end
-   end
-
-   view :pointer_items, tags: :unknown_ok do |args|
-     super(args.merge(item: :link))
-   end
-
-   view :errors, perms: :none do |args|
-     if card.errors.any?
-       if card.errors.find { |attrib,msg| attrib == :permission_denied }
-         Env.save_interrupted_action(request.env['REQUEST_URI'])
-         title = "Problems with #{card.name}"
-         frame args.merge(panel_class: "panel panel-warning", title: title, hide: 'menu' ) do
-           "Please #{ link_to 'sign in', card_url(':signin') }" #" #{to_task}"
-         end
-       else
-         super(args)
-       end
-     end
-   end
+    HTML
+  end
+
+  def followed_by_option
+    hash = Hash.new { |h, k| h[k] = [] }
+    card.item_cards.each do |follow_rule|
+      follow_rule.item_cards.each do |follow_option|
+        hash[follow_option.codename.to_sym] << follow_rule
+      end
+    end
+  end
+
+  def each_suggestion
+    if (suggestions = Card['follow suggestions'])
+      suggestions.item_names.each do |sug|
+        if (set_card = Card.fetch sug.to_name.left) &&
+          set_card.type_code == :set
+          option_card = Card.fetch(sug.to_name.right) ||
+            Card[sug.to_name.right.to_sym]
+          option = if option_card.follow_option?
+                     option_card.name
+                   else
+                     '*always'
+                   end
+          yield(set_card, option)
+        elsif (set_card = Card.fetch sug) && set_card.type_code == :set
+          yield(set_card, '*always')
+        end
+      end
+    end
+  end
+
+  # returns hashes with existing and suggested follow options
+  # structure:
+  # set_pattern_class => [ {card: rule_card, options: ['*always', '*created'] },.... ]
+  def followed_by_set
+    res = Hash.new { |h, k| h[k] = [] }
+    never = Card[:never].name
+    card.item_cards.each do |follow_rule|
+      options = follow_rule.item_names.reject { |item| item == never }
+      res[follow_rule.rule_set.subclass_for_set] << { card: follow_rule,
+                                                      options: options }
+    end
 
+    if Auth.signed_in? && Auth.current_id == card.left.id
+      each_suggestion do |set_card, option|
+        suggested_rule_name = set_card.follow_rule_name(card.trunk)
+        rule = res[set_card.subclass_for_set].find do |rule|
+          rule[:card].name == suggested_rule_name
+        end
+        if rule
+          rule[:options] << option unless rule[:options].include? option
+        else
+          rule_card = Card.new(name: suggested_rule_name)
+          res[set_card.subclass_for_set] << { card: rule_card,
+                                              options: [option] }
+        end
+      end
+    end
+    res
+  end
+
+  view :following_list do |_args|
+    if !Auth.signed_in? || Auth.current_id != card.left.id
+      hide_buttons = [:delete_follow_rule_button, :add_follow_rule_button]
+    end
+
+    sets = followed_by_set
+    wrap_with :div, class: 'pointer-list-editor' do
+      wrap_with :ul, class: 'delete-list list-group' do
+        Card.set_patterns.select { |p| sets[p] }.reverse.map do |set_pattern|
+          sets[set_pattern].map do |rule|
+            rule[:options].map do |option|
+              content_tag :li, class: 'list-group-item' do
+                subformat(rule[:card]).render_follow_item condition: option,
+                                                          hide: hide_buttons
+              end
+            end.join("\n")
+          end.join("\n")
+        end.join("\n")
+      end
+    end
+  end
+
+  view :ignoring_list do |_args|
+    ignore_list = []
+    card.item_cards.each do |follow_rule|
+      follow_rule.item_cards.each do |follow_option|
+        ignore_list << follow_rule if follow_option.codename.to_sym == :never
+      end
+    end
+    if !Auth.signed_in? || Auth.current_id != card.left.id
+      hide_buttons = [:delete_follow_rule_button, :add_follow_rule_button]
+    end
+    never = Card[:never].name
+    wrap_with :div, class: 'pointer-list-editor' do
+      wrap_with :ul, class: 'delete-list list-group' do
+        ignore_list.map do |rule_card|
+          content_tag :li, class: 'list-group-item' do
+            subformat(rule_card).render_follow_item condition: never,
+                                                    hide: hide_buttons
+          end
+        end.join "\n"
+      end
+    end
+  end
+
+  view :pointer_items, tags: :unknown_ok do |args|
+    super(args.merge(item: :link))
+  end
+
+  view :errors, perms: :none do |args|
+    if card.errors.any?
+      if card.errors.find { |attrib, _msg| attrib == :permission_denied }
+        Env.save_interrupted_action(request.env['REQUEST_URI'])
+        title = "Problems with #{card.name}"
+        frame args.merge(panel_class: 'panel panel-warning',
+                         title: title, hide: 'menu') do
+          "Please #{link_to 'sign in', card_url(':signin')}" # " #{to_task}"
+        end
+      else
+        super(args)
+      end
+    end
+  end
 end
 
-format(:css ) { include Card::Set::Type::Pointer::CssFormat  }
+format(:css) { include Card::Set::Type::Pointer::CssFormat }