card 1.16.6 → 1.16.7

data/mod/04_settings/spec/set/right/script_spec.rb

@@ -7,15 +7,15 @@ describe Card::Set::Right::Script do
   let(:compressed_changed_js) { 'alert("Hello");'   }
   let(:new_js)                { 'alert( "Hey" );'   }
   let(:compressed_new_js)     { 'alert("Hey");'   }
-  
+
   it_should_behave_like 'pointer machine', that_produces_js do
-    let(:machine_card)  { Card.gimme! "test my style+*script", :type => :pointer, :content => ''}
-    let(:machine_input_card) { Card.gimme! "test js",  :type => Card::JavaScriptID, :content => js  }
-    let(:another_machine_input_card) { Card.gimme! "more js",  :type => Card::JavaScriptID, :content => new_js  }
+    let(:machine_card)  { Card.gimme! "test my style+*script", type: :pointer, content: ''}
+    let(:machine_input_card) { Card.gimme! "test js",  type: Card::JavaScriptID, content: js  }
+    let(:another_machine_input_card) { Card.gimme! "more js",  type: Card::JavaScriptID, content: new_js  }
     let(:expected_input_items) { nil }
     let(:input_type) { :java_script }
     let(:card_content) do
-       { in:           js,         out:     compressed_js, 
+       { in:           js,         out:     compressed_js,
          changed_in:   changed_js, changed_out: compressed_changed_js,
          new_in:       new_js,     new_out:     compressed_new_js
        }

data/mod/04_settings/spec/set/right/structure_spec.rb

@@ -2,21 +2,23 @@
 
 describe Card::Set::Right::Structure do
   it "closed_content is rendered as type + raw" do
-    template = Card.new(:name=>'A+*right+*structure', :content=>'[[link]] {{inclusion}}')
+    template = Card.new(name: 'A+*right+*structure', content: '[[link]] {{inclusion}}')
     expect(template.format._render(:closed_content)).to eq(
       '<a class="cardtype known-card" href="/Basic">Basic</a> : [[link]] {{inclusion}}'
     )
   end
 
   it "closed_content is rendered as type + raw" do
-    template = Card.new(:name=>'A+*right+*structure', :type=>'Html', :content=>'[[link]] {{inclusion}}')
+    template = Card.new(name: 'A+*right+*structure', type: 'Html', content: '[[link]] {{inclusion}}')
     expect(template.format._render(:closed_content)).to eq(
       '<a class="cardtype known-card" href="/HTML">HTML</a> : [[link]] {{inclusion}}'
     )
   end
 
+=begin
   it 'renders core as raw' do
     trs = Card.fetch('*type+*right+*structure').format.render_core
     expect(trs).to eq '{"type":"_left"}'
   end
+=end
 end

data/mod/04_settings/spec/set/right/style_spec.rb

@@ -5,22 +5,22 @@ require File.expand_path('../../../../../03_machines/spec/lib/shared_machine_exa
 describe Card::Set::Right::Style do
 #  describe "#delet"
 #  it "should delete tempfile"
-  #let!(:skin_card)              { Card.gimme! "test skin", :type => :skin, :content => '[[test css]]'}
+  #let!(:skin_card)              { Card.gimme! "test skin", type: :skin, content: '[[test css]]'}
   let(:css)                    { "#box { display: block }"  }
   let(:compressed_css)         { "#box{display:block}\n"    }
   let(:changed_css)            { "#box { display: inline }" }
   let(:compressed_changed_css) { "#box{display:inline}\n"   }
   let(:new_css)                { "#box{ display: none}\n"   }
-  let(:compressed_new_css)     { "#box{display:none}\n"   }  
-  
+  let(:compressed_new_css)     { "#box{display:none}\n"   }
+
   it_should_behave_like 'pointer machine', that_produces_css do
-    let(:machine_card)  { Card.gimme! "test my style+*style", :type => :pointer, :content => ''}
-    let(:machine_input_card) { Card.gimme! "test css",  :type => :css, :content => css  }
-    let(:another_machine_input_card) { Card.gimme! "more css",  :type => :css, :content => new_css  }
+    let(:machine_card)  { Card.gimme! "test my style+*style", type: :pointer, content: ''}
+    let(:machine_input_card) { Card.gimme! "test css",  type: :css, content: css  }
+    let(:another_machine_input_card) { Card.gimme! "more css",  type: :css, content: new_css  }
     let(:expected_input_items) { nil } #[Card.fetch("test skin"), machine_input_card] }
     let(:input_type) { :css }
     let(:card_content) do
-       { in:           css,         out:     compressed_css, 
+       { in:           css,         out:     compressed_css,
          changed_in:   changed_css, changed_out: compressed_changed_css,
          new_in:       new_css,     new_out:     compressed_new_css
        }

data/mod/04_settings/spec/set/type/setting_spec.rb

@@ -3,8 +3,8 @@
 describe Card::Set::Type::Setting do
   context "core view" do
     it 'should have a table' do
-      core = render_card :core, :name=>:help
-      assert_view_select core, 'table' 
+      core = render_card :core, name: :help
+      assert_view_select core, 'table'
     end
   end
 end

data/mod/05_email/lib/card/follow_option.rb

@@ -5,29 +5,29 @@ class Card
   module FollowOption
     mattr_reader :test, :follower_candidate_ids
     @@test, @@follower_candidate_ids = {}, {}
-    
-    @@options = { :all=>[], :main=>[], :restrictive=>[] }
-    
-    def self.included(host_class)     
+
+    @@options = { all: [], main: [], restrictive: [] }
+
+    def self.included(host_class)
        host_class.extend ClassMethods
     end
-    
+
     def self.codenames type=:all
       @@options[type]
     end
-    
+
     def self.cards
        codenames.map { |codename| Card[codename] }
     end
-    
+
     def self.restrictive_options
       self.codenames :restrictive
     end
-    
+
     def self.main_options
       self.codenames :main
     end
-    
+
     def restrictive_option?
       Card::FollowOption.restrictive_options.include? codename
     end
@@ -37,39 +37,39 @@ class Card
     end
 
     module ClassMethods
-      
+
       # args:
-      # :position => <Fixnum> (starting at 1, default: add to end)
+      # position: <Fixnum> (starting at 1, default: add to end)
       def restrictive_follow_opts args
         add_option args, :restrictive
       end
-      
+
       # args:
-      # :position => <Fixnum> (starting at 1, default: add to end)
+      # position: <Fixnum> (starting at 1, default: add to end)
       def follow_opts args
         add_option args, :main
       end
-      
+
       def follow_test opts={}, &block
         Card::FollowOption.test[ get_codename(opts) ] = block
       end
-      
+
       def follower_candidate_ids opts={}, &block
         Card::FollowOption.follower_candidate_ids[ get_codename(opts) ] = block
       end
-            
+
       private
-      
+
       def insert_option pos, item, type
-        if Card::FollowOption.codenames(type)[pos]  
+        if Card::FollowOption.codenames(type)[pos]
           Card::FollowOption.codenames(type).insert(pos, item)
-        else  
+        else
           # If pos > codenames.size in a previous insert then we have a bunch of preceding nils in the array.
           # Hence, we have to overwrite a nil value if we encounter one and can't use insert.
           Card::FollowOption.codenames(type)[pos] = item
         end
       end
-      
+
       def add_option opts, type, &block
         codename = get_codename opts
         if opts[:position]
@@ -79,12 +79,12 @@ class Card
         end
         Card::FollowOption.codenames(:all) << codename
       end
-      
+
       def get_codename opts
         opts[:codename] || self.name.match(/::(\w+)$/)[1].underscore.to_sym
       end
-      
-      
-    end   
+
+
+    end
   end
 end

data/mod/05_email/set/all/follow.rb

@@ -2,19 +2,23 @@ card_accessor :followers
 
 FOLLOWER_IDS_CACHE_KEY = 'FOLLOWER_IDS'
 
-event :cache_expired_because_of_new_set, :before=>:store, :on=>:create, :when=>proc { |c| c.type_id == Card::SetID } do
+event :cache_expired_for_new_set, before: :store, on: :create,
+  when: proc { |c| c.type_id == Card::SetID } do
   Card.follow_caches_expired
 end
 
-event :cache_expired_because_of_type_change, :before=>:store, :changed=>:type_id do  #FIXME expire (also?) after save
+event :cache_expired_for_type_change, before: :store, changed: :type_id do
+  #FIXME expire (also?) after save
   Card.follow_caches_expired
 end
 
-event :cache_expired_because_of_name_change, :before=>:store, :changed=>:name do
+event :cache_expired_for_name_change, before: :store, changed: :name do
   Card.follow_caches_expired
 end
 
-event :cache_expired_because_of_new_user_rule, :before=>:extend, :when=>proc { |c| c.follow_rule_card? }  do
+event :cache_expired_for_new_user_rule, before: :extend,
+  when: proc { |c| c.follow_rule_card? }  do
+
   Card.follow_caches_expired
 end
 
@@ -22,21 +26,25 @@ format do
 
   def follow_link_hash args
     toggle = args[:toggle] || ( card.followed? ? :off : :on )
-    hash = { :class => "follow-toggle-#{toggle}" }
+    hash = { class: "follow-toggle-#{toggle}" }
+    these_emails = "emails about changes to #{card.follow_label}"
     case toggle
     when :off
       hash[:content] = '*never'
-      hash[:title]   = "stop sending emails about changes to #{card.follow_label}"
+      hash[:title]   = "stop sending #{these_emails}"
       hash[:verb]    = 'unfollow'
     when :on
       hash[:content] = '*always'
-      hash[:title]   = "send emails about changes to #{card.follow_label}"
+      hash[:title]   = "send #{these_emails}"
       hash[:verb]    = 'follow'
     end
-    follow_rule_name = card.default_follow_set_card.follow_rule_name( Auth.current.name )
-    hash[:path] = path :name=>follow_rule_name, :action=>:update,
-                       :success=>{ :layout=>:modal, :view=>:follow_status },
-                       :card=>{ :content=>"[[#{hash[:content]}]]" }
+    set_card = card.default_follow_set_card
+    hash[:path] = path(
+      name: set_card.follow_rule_name( Auth.current.name),
+      action: :update,
+      success: { layout: :modal, view: :follow_status },
+      card: { content: "[[#{hash[:content]}]]" }
+    )
     hash
   end
 
@@ -50,14 +58,14 @@ end
 
 format :html do
 
-  view :follow_link, :tags=>:unknown_ok, :perms=>:none do |args|
+  view :follow_link, tags: :unknown_ok, perms: :none do |args|
     hash = follow_link_hash args
     text = args[:icon] ? glyphicon('flag') : ''
     text += %[<span class="follow-verb menu-item-label">#{hash[:verb]}</span>].html_safe
-    follow_rule_card = Card.fetch(card.default_follow_set_card.follow_rule_name( Auth.current.name ), :new=>{})
+    follow_rule_card = Card.fetch(card.default_follow_set_card.follow_rule_name( Auth.current.name ), new: {})
     opts = ( args[:html_args] || {} ).clone
     opts.merge!(
-      :title           => hash[:title],
+      title:           hash[:title],
       'data-path'      => hash[:path],
       'data-toggle'    => 'modal',
       'data-target'    => "#modal-#{card.cardname.safe_key}",
@@ -114,7 +122,7 @@ end
 
 
 def follow_rule_applies? follower_id
-  follow_rule = rule :follow, :user_id=>follower_id
+  follow_rule = rule :follow, user_id: follower_id
   if follow_rule.present?
     follow_rule.split("\n").each do |value|
 
@@ -210,7 +218,7 @@ def all_direct_follower_ids_with_reason
       set_card.all_user_ids_with_rule_for(:follow).each do |user_id|
         if (!visited.include?(user_id)) && (follow_option = self.follow_rule_applies?(user_id))
           visited << user_id
-          yield(user_id, :set_card=>set_card, :option=>follow_option)
+          yield(user_id, set_card: set_card, option: follow_option)
         end
       end
     end

data/mod/05_email/set/all/notify.rb

@@ -11,16 +11,16 @@ class FollowerStash
       if !@visited.include? card.key
         @visited.add card.key
         card.all_direct_follower_ids_with_reason do |user_id, reason|
-          notify Card.fetch(user_id), :of=>reason
+          notify Card.fetch(user_id), of: reason
         end
         if card.left and !@visited.include?(card.left.name) and follow_field_rule = card.left.rule_card(:follow_fields)
 
-          follow_field_rule.item_names(:context=>card.left.cardname).each do |item|
+          follow_field_rule.item_names(context: card.left.cardname).each do |item|
             if @visited.include? item.to_name.key
               add_affected_card card.left
               break
             elsif item.to_name.key == Card[:includes].key
-              includee_set = Card.search(:included_by=>card.left.name).map(&:key)
+              includee_set = Card.search(included_by: card.left.name).map(&:key)
               if !@visited.intersection(includee_set).empty?
                 add_affected_card card.left
                 break
@@ -66,19 +66,19 @@ def notable_change?
   !silent_change && !supercard && current_act && Card::Auth.current_id != WagnBotID && followable?
 end
 
-event :notify_followers_after_save, :after=>:subsequent, :on=>:save, :when=>proc{ |ca| ca.notable_change? } do
+event :notify_followers_after_save, after: :subsequent, on: :save, when: proc{ |ca| ca.notable_change? } do
   notify_followers
 end
 
 # in the delete case we have to calculate the follower_stash beforehand
 # but we can't pass the follower_stash through the ActiveJob queue.
 # We have to deal with the notifications in the extend phase instead of the subsequent phase
-event :stash_followers, :after=>:approve, :on=>:delete do
+event :stash_followers, after: :approve, on: :delete do
   act_card.follower_stash ||=  FollowerStash.new
   act_card.follower_stash.add_affected_card self
 end
-event :notify_followers_after_delete, :after=>:extend, :on=>:delete,
-    :when=>proc{ |ca| ca.notable_change? } do
+event :notify_followers_after_delete, after: :extend, on: :delete,
+    when: proc{ |ca| ca.notable_change? } do
   notify_followers
 end
 
@@ -102,7 +102,7 @@ def notify_followers
 end
 
 format do
-  view :list_of_changes, :denial=>:blank do |args|
+  view :list_of_changes, denial: :blank do |args|
     action = get_action(args)
 
     relevant_fields = case action.action_type
@@ -117,10 +117,11 @@ format do
   end
 
 
-  view :subedits, :perms=>:none do |args|
-    subedits = get_act(args).relevant_actions_for(card).map do |action|
+  view :subedits, perms: :none do |args|
+    subedits =
+      get_act(args).relevant_actions_for(card).map do |action|
         if action.card_id != card.id
-          action.card.format(:format=>@format).render_subedit_notice(:action=>action)
+          action.card.format(format: @format).render_subedit_notice(action: action)
         end
       end.compact.join
 
@@ -131,7 +132,7 @@ format do
     end
   end
 
-  view :subedit_notice, :denial=>:blank do |args|
+  view :subedit_notice, denial: :blank do |args|
     action = get_action(args)
     name_before_action = (action.new_values[:name] && action.old_values[:name]) || card.name
 
@@ -139,7 +140,7 @@ format do
 #{ render_list_of_changes(args) }}
   end
 
-  view :followed, :perms=>:none, :closed=>true do |args|
+  view :followed, perms: :none, closed: true do |args|
     if args[:followed_set] && (set_card = Card.fetch(args[:followed_set])) &&
          args[:follow_option] && (option_card = Card.fetch(args[:follow_option]))
        option_card.description set_card
@@ -148,15 +149,15 @@ format do
     end
   end
 
-  view :follower, :perms=>:none, :closed=>true do |args|
+  view :follower, perms: :none, closed: true do |args|
     args[:follower] || 'follower'
   end
 
-  view :unfollow_url, :perms=>:none, :closed=>true do |args|
+  view :unfollow_url, perms: :none, closed: true do |args|
     if args[:followed_set] && (set_card = Card.fetch(args[:followed_set])) && args[:follow_option] && args[:follower]
      rule_name = set_card.follow_rule_name args[:follower]
      target_name = "#{args[:follower]}+#{Card[:follow].name}"
-     update_path = page_path target_name, :action=>:update, :card=>{:subcards=>{rule_name=>Card[:never].name}}
+     update_path = page_path target_name, action: :update, card: {subcards: {rule_name=>Card[:never].name}}
      card_url update_path # absolutize path
     end
   end
@@ -171,11 +172,12 @@ format do
     end
     item_title +=  "#{field}: "
 
-    item_value = if action.action_type == :delete
-      action.old_values[field]
-    else
-      action.new_values[field]
-    end
+    item_value =
+      if action.action_type == :delete
+        action.old_values[field]
+      else
+        action.new_values[field]
+      end
 
      wrap_list_item "#{item_title}#{item_value}"
   end
@@ -208,14 +210,14 @@ end
 
 
 format :email_text do
-  view :last_action, :perms=>:none do |args|
+  view :last_action, perms: :none do |args|
     act = get_act(args)
     "#{act.main_action.action_type}d"
   end
 end
 
 format :email_html do
-  view :last_action, :perms=>:none do |args|
+  view :last_action, perms: :none do |args|
     act = get_act(args)
     "#{act.main_action.action_type}d"
   end

data/mod/05_email/set/all/observer.rb

@@ -7,8 +7,8 @@ end
 
 def email_templates_for setting
 
-  if email_templates = @email_template_cache ||
-      ( event_card = self.rule_card(setting) and event_card.extended_item_cards )
+  if (email_templates = @email_template_cache ||
+      ((event_card = self.rule_card(setting)) && event_card.extended_item_cards))
     email_templates.each do |mailcard|
       yield(mailcard)
     end
@@ -16,12 +16,12 @@ def email_templates_for setting
 end
 
 [:create, :update, :delete].each do |action|
-  event "observer_#{action}".to_sym, :after=>:extend, :on=>action do
-    self.send_action_mails :on=>action
+  event "observer_#{action}".to_sym, after: :extend, on: action do
+    self.send_action_mails on: action
   end
 end
 
-event :cache_delete_email_templates, :after=>:approve, :on=>:delete do
+event :cache_delete_email_templates, after: :approve, on: :delete do
   event_card = self.rule_card(:on_delete)
   @email_template_cache = event_card && event_card.extended_item_cards
 end