card 1.16.14 → 1.16.15

data/mod/02_basic_types/set/all/base.rb

@@ -6,9 +6,30 @@ format do
   end
 
   # NAME VIEWS
-
   simple_args = { closed: true, perms: :none }
-  view(:name,     simple_args) { card.name                           }
+  view :name, simple_args do |args|
+    return card.name unless args[:variant]
+    args[:variant].split(/[\s,]+/).inject(card.name) do |name, variant|
+      case variant.to_sym
+      when :capitalized
+        name.capitalize
+      when :singular
+        name.singularize
+      when :plural
+        name.pluralize
+      when :title
+        name.titleize
+      else
+        if ::Set.new([
+          :downcase, :upcase, :swapcase, :reverse, :succ
+        ]).include?(variant.to_sym)
+          name.send variant
+        else
+          name
+        end
+      end
+    end
+  end
   view(:key,      simple_args) { card.key                            }
   view(:title,    simple_args) { |args| args[:title] || card.name    }
   view(:linkname, simple_args) { card.cardname.url_key               }

data/mod/02_basic_types/set/type/pointer.rb

@@ -12,6 +12,20 @@ event :insert_item_event, before: :approve, on: :save, when: proc {|c| Env.param
   self.insert_item index.to_i, Env.params['insert_item']
 end
 
+phase_method :changed_item_names do
+  dropped_item_names + added_item_names
+end
+
+phase_method :dropped_item_names do
+  old_items = item_names content: db_content_was
+  old_items - item_names
+end
+
+phase_method :added_item_names do
+  old_items = item_names content: db_content_was
+  item_names - old_items
+end
+
 format do
   def item_links args={}
     card.item_cards(args).map do |item_card|
@@ -290,37 +304,38 @@ def item_type
 end
 
 def items= array
-  self.content=''
+  self.content = ''
   array.each { |i| self << i }
   save!
 end
 
 def << item
-  newname = case item
-    when Card     ;  item.name
-    when Integer  ;  c = Card[item] and c.name
-    else             item
+  newname =
+    case item
+    when Card    then item.name
+    when Integer then (c = Card[item]) && c.name
+    else              item
     end
   add_item newname
 end
 
 def add_item name
-  unless include_item? name
-    self.content="[[#{(item_names << name).reject(&:blank?)*"]]\n[["}]]"
-  end
+  return if include_item? name
+  self.content = "[[#{(item_names << name).reject(&:blank?) * "]]\n[["}]]"
 end
+
 def add_item! name
   add_item name
   save!
 end
 
 def drop_item name
-  if include_item? name
-    key = name.to_name.key
-    new_names = item_names.reject{ |n| n.to_name.key == key }
-    self.content = new_names.empty? ? '' : "[[#{new_names * "]]\n[["}]]"
-  end
+  return unless include_item? name
+  key = name.to_name.key
+  new_names = item_names.reject { |n| n.to_name.key == key }
+  self.content = new_names.empty? ? '' : "[[#{new_names * "]]\n[["}]]"
 end
+
 def drop_item! name
   drop_item name
   save!
@@ -328,43 +343,37 @@ end
 
 def insert_item index, name
   new_names = item_names
-  new_names.delete(name)
-  new_names.insert(index,name)
-  self.content =  new_names.map { |name| "[[#{name}]]" }.join "\n"
+  new_names.delete name
+  new_names.insert index, name
+  self.content = new_names.map { |new_name| "[[#{new_name}]]" }.join "\n"
 end
+
 def insert_item! index, name
   insert_item index, name
   save!
 end
 
-
 def options_rule_card
-  self.rule_card :options
+  rule_card :options
 end
 
 def option_names
-  result_cards = if (oc = options_rule_card)
-    oc.item_names default_limit: 50, context: name
-  else
-    Card.search sort: 'name', limit: 50, return: :name
-  end
+  result_names =
+    if (oc = options_rule_card)
+      oc.item_names default_limit: 50, context: name
+    else
+      Card.search({ sort: 'name', limit: 50, return: :name },
+                  "option names for pointer: #{name}")
+    end
   if (selected_options = item_names)
-    result_cards = result_cards | selected_options
+    result_names += selected_options
+    result_names.uniq!
   end
-  result_cards
+  result_names
 end
 
 def option_cards
-  result_cards = if (oc = options_rule_card)
-    oc.item_cards default_limit: 50, context: name
-  else
-    Card.search sort: 'alpha', limit: 50
-  end
-  if (selected_options = item_names)
-    selected_options.each do |item|
-      result_cards.push Card.fetch(item,new: {})
-    end
-    result_cards.uniq!
+  option_names.map do |name|
+    Card.fetch name, new: {}
   end
-  result_cards
 end

data/mod/02_basic_types/spec/set/all/base_spec.rb

@@ -1,26 +1,41 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Base do
-
   describe 'handles view' do
+    describe 'name view' do
+      it('name') { expect(render_card(:name)).to eq('Tempo Rary') }
+      it 'pluralizes' do
+        name = render_content '{{Joe User|name; variant: plural}}'
+        expect(name).to eq('Joe Users')
+      end
+      it 'singularizes' do
+        name = render_content '{{Sunglasses|name; variant: singular}}'
+        expect(name).to eq('Sunglass')
+      end
+      it 'handles more than one variant' do
+        name = render_content(
+          '{{Sunglasses|name; variant: singular, upcase}}'
+        )
+        expect(name).to eq('SUNGLASS')
+      end
+    end
 
-    it("name"    ) { expect(render_card(:name)).to      eq('Tempo Rary') }
-    it("key"     ) { expect(render_card(:key)).to       eq('tempo_rary') }
-    it("linkname") { expect(render_card(:linkname)).to  eq('Tempo_Rary') }
+    it('key'     ) { expect(render_card(:key)).to       eq('tempo_rary') }
+    it('linkname') { expect(render_card(:linkname)).to  eq('Tempo_Rary') }
 
-    it "url" do
+    it 'url' do
       Card::Env[:protocol] = 'http://'
       Card::Env[:host]     = 'eric.skippy.com'
       expect(render_card(:url)).to eq('http://eric.skippy.com/Tempo_Rary')
     end
 
     it :raw do
-      @a = Card.new content: "{{A}}"
-      expect(@a.format._render(:raw)).to eq("{{A}}")
+      @a = Card.new content: '{{A}}'
+      expect(@a.format._render(:raw)).to eq('{{A}}')
     end
 
-    it "core" do
-      expect(render_card(:core, name: 'A+B')).to eq("AlphaBeta")
+    it 'core' do
+      expect(render_card(:core, name: 'A+B')).to eq('AlphaBeta')
     end
 
     it 'core for new card' do
@@ -28,26 +43,28 @@ describe Card::Set::All::Base do
     end
 
     describe 'array' do
-      it "of search items" do
-        Card.create! name: "n+a", type: "Number", content: "10"
+      it 'of search items' do
+        Card.create! name: 'n+a', type: 'Number', content: '10'
         sleep 1
-        Card.create! name: "n+b", type: "Phrase", content: "say:\"what\""
+        Card.create! name: 'n+b', type: 'Phrase', content: "say:\"what\""
         sleep 1
-        Card.create! name: "n+c", type: "Number", content: "30"
-        c = Card.new name: 'nplusarray', content: "{{n+*children+by create|array}}"
-        expect(c.format._render( :core )).to eq(%{["10", "say:\\"what\\"", "30"]})
+        Card.create! name: 'n+c', type: 'Number', content: '30'
+        c = Card.new name: 'nplusarray',
+                     content: '{{n+*children+by create|array}}'
+        expect(c.format._render(:core)).to eq(%{["10", "say:\\"what\\"", "30"]})
       end
 
-      it "of pointer items" do
-        Card.create! name: "n+a", type: "Number", content: "10"
-        Card.create! name: "n+b", type: "Number", content: "20"
-        Card.create! name: "n+c", type: "Number", content: "30"
-        Card.create! name: "npoint", type: "Pointer", content: "[[n+a]]\n[[n+b]]\n[[n+c]]"
-        c = Card.new name: 'npointArray', content: "{{npoint|array}}"
-        expect(c.format._render( :core )).to eq(%q{["10", "20", "30"]})
+      it 'of pointer items' do
+        Card.create! name: 'n+a', type: 'Number', content: '10'
+        Card.create! name: 'n+b', type: 'Number', content: '20'
+        Card.create! name: 'n+c', type: 'Number', content: '30'
+        Card.create! name: 'npoint', type: 'Pointer',
+                     content: "[[n+a]]\n[[n+b]]\n[[n+c]]"
+        c = Card.new name: 'npointArray', content: '{{npoint|array}}'
+        expect(c.format._render(:core)).to eq(%{["10", "20", "30"]})
       end
 
-      it "of basic items" do
+      it 'of basic items' do
         expect(render_card(:array, content: 'yoing')).to eq(%{["yoing"]})
       end
     end
@@ -69,4 +86,3 @@ describe Card::Set::All::Base do
     end
   end
 end
-

data/mod/02_basic_types/spec/set/type/pointer_spec.rb

@@ -50,6 +50,93 @@ describe Card::Set::Type::Pointer do
   end
 
 
+  let(:pointer) do
+    Card.create name: 'tp', type: 'pointer',
+                content: "[[item1]]\n[[item2]]"
+  end
+
+  describe '#added_item_names' do
+    it 'recognizes added items' do
+      Card::Auth.as_bot do
+        pointer
+        in_phase before: :approve,
+                 on: :save,
+                 trigger: ->{
+                   pointer.update_attributes!(
+                     content: "[[item1]]\n[[item2]]\n[[item3]]"
+                  )
+                } do
+          expect(added_item_names).to eq ['item3']
+        end
+      end
+    end
+
+    it 'ignores order' do
+      Card::Auth.as_bot do
+        pointer
+        in_phase before: :approve,
+                 on: :save,
+                 trigger: ->{
+                   pointer.update_attributes!(
+                     content: "[[item2]]\n[[item1]]"
+                   )
+                 } do
+          expect(added_item_names).to eq []
+        end
+      end
+    end
+  end
+
+  describe '#dropped_item_names' do
+    it 'recognizes dropped items' do
+      Card::Auth.as_bot do
+        pointer
+        in_phase before: :approve,
+                 on: :save,
+                 trigger: ->{
+                   pointer.update_attributes!(
+                     content: "[[item1]]"
+                   )
+                 } do
+          expect(dropped_item_names).to eq ['item2']
+        end
+      end
+    end
+
+    it 'ignores order' do
+      Card::Auth.as_bot do
+        pointer
+        in_phase before: :approve,
+                 on: :save,
+                 trigger: ->{
+                   pointer.update_attributes!(
+                     content: "[[item2]]\n[[item1]]"
+                   )
+                 } do
+          expect(dropped_item_names).to eq []
+        end
+      end
+    end
+  end
+
+  describe '#changed_item_names' do
+    it 'recognizes changed items' do
+      Card::Auth.as_bot do
+        pointer
+        in_phase before: :approve,
+                 on: :save,
+                 trigger: ->{
+                   pointer.update_attributes!(
+                     content: "[[item1]]\n[[item3]]"
+                   )
+                 } do
+          expect(changed_item_names.sort).to eq ['item2','item3']
+        end
+      end
+    end
+  end
+
+
 
   describe 'html' do
     before do

data/mod/03_machines/set/right/machine_output.rb

@@ -9,7 +9,7 @@ end
 format do
   view :not_found do |args|
     if update_machine_output_live?
-      Card::Cache.reset_global # FIXME - wow, this kind of hard core, no?
+      Card::Cache.reset_global # FIXME: wow, this is overkill, no?
       root.error_status = 302
       card.left.update_machine_output
       card_path card.left.machine_output_url
@@ -19,10 +19,14 @@ format do
   end
 
   def update_machine_output_live?
-    said = card.selected_action_id
-    card.left.kind_of? Machine and                                  # must be a machine
-    !card.left.locked?         and                                  # machine must not already be running
-    ( card.new_card? or !said or said == card.last_action_id )      # must want current output (won't re-output old stuff)
+    case
+    when !card.left.is_a?(Machine) then false # must be a machine
+    when card.left.locked?         then false # machine must not be running
+    when card.new_card?            then true  # always update if new
+    else
+      # must want current output (won't re-output old stuff)
+      (selected_id = card.selected_action_id) &&
+        selected_id == card.last_action_id
+    end
   end
-
 end

data/mod/04_settings/set/abstract/permission.rb

@@ -3,13 +3,16 @@ def standardize_items
 end
 
 format :html do
-
-  view :pointer_core do |args| #, view: :core, mod: Type::Pointer::HtmlFormat
-    %{<div class="pointer-list">#{ render_pointer_items args }</div>}
+  view :pointer_core do |args| # view: :core, mod: Type::Pointer::HtmlFormat
+    %{<div class="pointer-list">#{render_pointer_items args}</div>}
   end
 
   view :core do |args|
-    card.content=='_left' ? core_inherit_content(args) : render( :pointer_core, args )
+    if card.content == '_left'
+      core_inherit_content args
+    else
+      render :pointer_core, args
+    end
   end
 
   view :closed_content do |args|
@@ -22,7 +25,9 @@ format :html do
     set_card = Card.fetch(set_name)
     not_set = set_card && set_card.type_id != SetID
 
-    group_options = Auth.as_bot { Card.search(type_id: RoleID, sort: 'name') }
+    group_options = Auth.as_bot do
+      Card.search({ type_id: RoleID, sort: 'name' }, 'roles by name')
+    end
 
     inheritable = not_set ? false : set_card.inheritable?
     inheriting = inheritable && card.content=='_left'

data/mod/04_settings/set/type/setting.rb

@@ -2,7 +2,10 @@ require_dependency 'json'
 
 def self.member_names
   @@member_names ||= begin
-    Card.search( type_id: SettingID, return: 'key' ).inject({}) do |hash, card_key|
+    Card.search(
+      { type_id: SettingID, return: 'key' },
+      'all setting cards'
+    ).inject({}) do |hash, card_key|
       hash[card_key] = true
       hash
     end

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

@@ -2,30 +2,33 @@ card_accessor :followers
 
 FOLLOWER_IDS_CACHE_KEY = 'FOLLOWER_IDS'
 
-event :cache_expired_for_new_set, before: :store, on: :create,
-  when: proc { |c| c.type_id == Card::SetID } do
+# FIXME: this should be in type/set
+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_for_type_change, before: :store, changed: :type_id do
-  #FIXME expire (also?) after save
+event :cache_expired_for_type_change, before: :store, on: :update,
+                                      changed: :type_id do
+  # FIXME: expire (also?) after save
   Card.follow_caches_expired
 end
 
-event :cache_expired_for_name_change, before: :store, changed: :name do
+event :cache_expired_for_name_change, before: :store, on: :update,
+                                      changed: :name do
   Card.follow_caches_expired
 end
 
-event :cache_expired_for_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
 
 format do
-
   def follow_link_hash args
-    toggle = args[:toggle] || ( card.followed? ? :off : :on )
+    toggle = args[:toggle] || (card.followed? ? :off : :on)
     hash = { class: "follow-toggle-#{toggle}" }
     these_emails = "emails about changes to #{card.follow_label}"
     case toggle
@@ -40,14 +43,13 @@ format do
     end
     set_card = card.default_follow_set_card
     hash[:path] = path(
-      name: set_card.follow_rule_name( Auth.current.name),
+      name: set_card.follow_rule_name(Auth.current.name),
       action: :update,
       success: { layout: :modal, view: :follow_status },
       card: { content: "[[#{hash[:content]}]]" }
     )
     hash
   end
-
 end
 
 format :json do
@@ -57,13 +59,16 @@ format :json do
 end
 
 format :html do
-
   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: {})
-    opts = ( args[:html_args] || {} ).clone
+    span_attrs = 'follow-verb menu-item-label'
+    text += %[<span class="#{span_attrs}">#{hash[:verb]}</span>].html_safe
+    # 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],
       'data-path'      => hash[:path],
@@ -73,10 +78,8 @@ format :html do
     opts[:class] = "follow-link #{opts[:class]}"
     link_to text, hash[:path], opts
   end
-
 end
 
-
 def follow_label
   name
 end
@@ -91,7 +94,6 @@ def follower_names
   followers.map(&:name)
 end
 
-
 def follow_rule_card?
   is_user_rule? && rule_setting_name == '*follow'
 end
@@ -100,19 +102,16 @@ def follow_option?
   codename && FollowOption.codenames.include?(codename.to_sym)
 end
 
-# used for the follow menu
-# overwritten in type/set.rb and type/cardtype.rb
-# for sets and cardtypes it doesn't check whether the users is following the card itself
-# instead it checks whether he is following the complete set
+# used for the follow menu overwritten in type/set.rb and type/cardtype.rb
+# for sets and cardtypes it doesn't check whether the users is following the
+# card itself instead it checks whether he is following the complete set
 def followed_by? user_id
   with_follower_candidate_ids do
-    if follow_rule_applies? user_id
-      return true
-    end
-    if left_card = left and left_card.followed_field?(self) && left_card.followed_by?(user_id)
-      return true
-    end
-    return false
+    return true if follow_rule_applies? user_id
+    return true if (left_card = left) &&
+                   left_card.followed_field?(self) &&
+                   left_card.followed_by?(user_id)
+    false
   end
 end
 
@@ -120,16 +119,14 @@ def followed?
   followed_by? Auth.current_id
 end
 
-
 def follow_rule_applies? follower_id
   follow_rule = rule :follow, user_id: follower_id
   if follow_rule.present?
     follow_rule.split("\n").each do |value|
-
       value_code = value.to_name.code
       accounted_ids = (
-        @follower_candidate_ids[ value_code ] ||=
-          if block = FollowOption.follower_candidate_ids[ value_code ]
+        @follower_candidate_ids[value_code] ||=
+          if (block = FollowOption.follower_candidate_ids[value_code])
             block.call self
           else
             []
@@ -137,37 +134,35 @@ def follow_rule_applies? follower_id
       )
 
       applicable =
-        if test = FollowOption.test[ value_code ]
+        if (test = FollowOption.test[value_code])
           test.call follower_id, accounted_ids
         else
           accounted_ids.include? follower_id
         end
 
-      return value.gsub( /[\[\]]/, '' ) if applicable
+      return value.gsub(/[\[\]]/, '') if applicable
     end
   end
-  return false
+  false
 end
 
-
 def with_follower_candidate_ids
   @follower_candidate_ids = {}
   yield
   @follower_candidate_ids = nil
 end
 
-
 # the set card to be followed if you want to follow changes of card
 def default_follow_set_card
   Card.fetch("#{name}+*self")
 end
 
-
 # returns true if according to the follow_field_rule followers of self also
 # follow changes of field_card
 def followed_field? field_card
-  (follow_field_rule = rule_card(:follow_fields)) || follow_field_rule.item_names.find do |item|
-     item.to_name.key == field_card.key ||  (item.to_name.key == Card[:includes].key && included_card_ids.include?(field_card.id) )
+  (follow_field_rule = rule_card(:follow_fields)) ||
+    follow_field_rule.item_names.find do |item|
+     item.to_name.key == field_card.key || (item.to_name.key == Card[:includes].key && included_card_ids.include?(field_card.id) )
   end
 end
 
@@ -195,7 +190,7 @@ end
 # all ids of users that follow this card because of a follow rule that applies
 # to this card doesn't include users that follow this card because they are
 # following parent cards or other cards that include this card
-def direct_follower_ids args={}
+def direct_follower_ids _args={}
   result = ::Set.new
   with_follower_candidate_ids do
     set_names.each do |set_name|
@@ -226,7 +221,7 @@ def all_direct_follower_ids_with_reason
   end
 end
 
-#~~~~~ cache methods
+# ~~~~~ cache methods
 
 def write_follower_ids_cache user_ids
   hash = Card.follower_ids_cache