card 1.17.4 → 1.18.0

data/mod/05_standard/spec/chunk/link_spec.rb

@@ -5,67 +5,94 @@ describe Card::Chunk::Link do
     text = args.delete(:text)
     format_args = args.delete(:format_args)
     assert_args = ['a']
-    args.each_pair do |key,val|
+    args.each_pair do |key, val|
       assert_args[0] << "[#{key}=\"#{val}\"]"
     end
     assert_args << { text: text } if text
     assert_view_select render_content(target, (format_args || {})), *assert_args
   end
 
-  it "handles unknown cards" do
-    assert_link '[[Nixon]]', class: "wanted-card", href: "/Nixon", text: 'Nixon'
+  it 'handles unknown cards' do
+    assert_link '[[Nixon]]', class: 'wanted-card', href: '/Nixon', text: 'Nixon'
   end
 
   it 'handles known cards' do
-    assert_link "[[A]]", class: "known-card", href: "/A", text: 'A'
+    assert_link '[[A]]', class: 'known-card', href: '/A', text: 'A'
   end
 
-
   it 'handles custom text' do
-    assert_link '[[Baines|Lyndon]]', class: "wanted-card", href: "/Baines", text: 'Lyndon'
+    assert_link '[[Baines|Lyndon]]', class: 'wanted-card', href: '/Baines',
+                                     text: 'Lyndon'
   end
 
-  it "handles relative names" do
+  it 'handles relative names' do
     @card = Card.new name: 'Kennedy'
-    assert_link '[[+Monroe]]'    , class: "wanted-card", href: "/Kennedy+Monroe", text: 'Kennedy+Monroe'
-    assert_link '[[_self+Exner]]', class: "wanted-card", href: "/Kennedy+Exner",  text: 'Kennedy+Exner'
-    assert_link '[[Onassis+]]'   , class: "wanted-card", href: "/Onassis+Kennedy",text: 'Onassis+Kennedy'
+    assert_link '[[+Monroe]]', class: 'wanted-card',
+                               href: '/Kennedy+Monroe',
+                               text: 'Kennedy+Monroe'
+    assert_link '[[_self+Exner]]', class: 'wanted-card',
+                                   href: '/Kennedy+Exner',
+                                   text: 'Kennedy+Exner'
+    assert_link '[[Onassis+]]', class: 'wanted-card',
+                                href: '/Onassis+Kennedy',
+                                text: 'Onassis+Kennedy'
   end
 
-  it "handles relative names in context" do
+  it 'handles relative names in context' do
     @card = Card.new name: 'Kennedy'
-    format_args = { context_names: [ 'Kennedy'.to_name ] }
-    assert_link '[[+Monroe]]'    , format_args: format_args, class: "wanted-card", href: "/Kennedy+Monroe", text: '+Monroe'
-    assert_link '[[_self+Exner]]', format_args: format_args, class: "wanted-card", href: "/Kennedy+Exner", text: '+Exner'
-    assert_link '[[Onassis+]]'   , format_args: format_args, class: "wanted-card", href: "/Onassis+Kennedy", text: 'Onassis'
+    format_args = { context_names: ['Kennedy'.to_name] }
+    assert_link '[[+Monroe]]', format_args: format_args,
+                               class: 'wanted-card',
+                               href: '/Kennedy+Monroe',
+                               text: '+Monroe'
+    assert_link '[[_self+Exner]]', format_args: format_args,
+                                   class: 'wanted-card',
+                                   href: '/Kennedy+Exner',
+                                   text: '+Exner'
+    assert_link '[[Onassis+]]', format_args: format_args,
+                                class: 'wanted-card',
+                                href: '/Onassis+Kennedy',
+                                text: 'Onassis'
   end
 
-  it "handles relative urls" do
-    assert_link '[[/recent]]', class: "internal-link", href: "/recent", text: '/recent'
+  it 'handles relative urls' do
+    assert_link '[[/recent]]', class: 'internal-link',
+                               href: '/recent',
+                               text: '/recent'
   end
 
-  it "handles absolute urls" do
-    assert_link '[[http://google.com]]', class: 'external-link', target: '_blank', href: 'http://google.com', text: 'http://google.com'
+  it 'handles absolute urls' do
+    assert_link '[[http://google.com]]',
+                class: 'external-link', target: '_blank',
+                href: 'http://google.com', text: 'http://google.com'
   end
 
-  it "should escape spaces in cardnames with %20 (not +)" do
-    assert_link '[[Marie "Mad Dog" Deatherage|Marie]]', class: "wanted-card", href: "/Marie_Mad_Dog_Deatherage?card%5Bname%5D=Marie+%22Mad+Dog%22+Deatherage", text: 'Marie'
+  it 'should escape spaces in cardnames with %20 (not +)' do
+    assert_link '[[Marie "Mad Dog" Deatherage|Marie]]',
+                class: 'wanted-card',
+                href: '/Marie_Mad_Dog_Deatherage' \
+                      '?card%5Bname%5D=Marie+%22Mad+Dog%22+Deatherage',
+                text: 'Marie'
   end
 
-
   it "doesn't escape content outside of link" do
-    content = render_content('wgw&nbsp; [[http://www.google.com|google]] &nbsp;  <br>')
-    expect(content).to eq "wgw&nbsp; <a target=\"_blank\" class=\"external-link\" href=\"http://www.google.com\">google</a> &nbsp;  <br>"
+    content =
+      render_content 'wgw&nbsp; [[http://www.google.com|google]] &nbsp;  <br>'
+    expect(content).to eq(
+      'wgw&nbsp; <a target="_blank" class="external-link" ' \
+      'href="http://www.google.com">google</a> &nbsp;  <br>'
+    )
   end
 
-  it "handles inclusions in link text" do
-    assert_link '[[linkies|{{namies|name}}]]', class: "wanted-card", href: "/linkies", text: 'namies'
+  it 'handles nests in link text' do
+    assert_link '[[linkies|{{namies|name}}]]',
+                class: 'wanted-card', href: '/linkies', text: 'namies'
   end
 
-  it "handles dot (.) in missing cardlink" do
-    assert_link "[[Wagn 1.10.12]]", class: "wanted-card", href: "/Wagn_1_10_12?card%5Bname%5D=Wagn+1.10.12", text: 'Wagn 1.10.12'
-
+  it 'handles dot (.) in missing cardlink' do
+    assert_link '[[Wagn 1.10.12]]',
+                class: 'wanted-card',
+                href: '/Wagn_1_10_12?card%5Bname%5D=Wagn+1.10.12',
+                text: 'Wagn 1.10.12'
   end
-
 end
-

data/mod/05_standard/spec/chunk/query_reference_spec.rb

@@ -1,50 +1,48 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Chunk::QueryReference, "QueryReference" do
-
-  context "syntax parsing" do
+describe Card::Chunk::QueryReference, 'QueryReference' do
+  context 'syntax parsing' do
     before do
-      @class= Card::Chunk::QueryReference
+      @class = Card::Chunk::QueryReference
     end
 
     let :query_refs do
-       content = Card::Content.new @content, Card.new(type: 'Search')
+      content = Card::Content.new @content, Card.new(type: 'Search')
        content.find_chunks(Card::Chunk::QueryReference)
     end
 
     subject { query_refs.first.name }
 
-    it "handles simple search" do
+    it 'handles simple search' do
       @content = '{"name":"Waldo"}'
       is_expected.to eq 'Waldo'
     end
 
-    it "handles operators" do
+    it 'handles operators' do
       @content = '{"name":["eq","Waldo"]}'
       is_expected.to eq 'Waldo'
     end
 
-    it "handles multiple values for operators" do
+    it 'handles multiple values for operators' do
       @content = '{"name":["in","Where","Waldo"]}'
       expect(query_refs[1].name).to eq 'Waldo'
     end
 
-    it "handles plus attributes" do
+    it 'handles plus attributes' do
       @content = '{"right_plus":["Waldo",{"content":"here"}]}'
-      is_expected.to eq  'Waldo'
+      is_expected.to eq 'Waldo'
     end
 
-    it "handles nested query structures" do
+    it 'handles nested query structures' do
       @content = '{"any":{"content":"Where", "right_plus":["is",{"name":"Waldo"}]}}'
       expect(query_refs[0].name).to eq 'Where'
       expect(query_refs[1].name).to eq 'is'
       expect(query_refs[2].name).to eq 'Waldo'
     end
 
-    it "handles contextual names" do
-      @content =  '{"name":"_+Waldo"}'
+    it 'handles contextual names' do
+      @content = '{"name":"_+Waldo"}'
       is_expected.to eq '_+Waldo'
     end
   end
-
 end

data/mod/05_standard/spec/set/all/email_html_spec.rb

@@ -1,14 +1,14 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::EmailHtmlFormat do
-  it "renders full urls" do
+  it 'renders full urls' do
     Card::Env[:protocol] = 'http://'
     Card::Env[:host] = 'www.fake.com'
     expect(render_content('[[B]]', format: 'email_html')).to eq('<a class="known-card" href="http://www.fake.com/B">B</a>')
   end
 
-  describe "raw view" do
-    it "renders missing included cards as blank" do
+  describe 'raw view' do
+    it 'renders missing included cards as blank' do
       expect(render_content('{{strombooby}}', format: 'email_html')).to eq('')
     end
   end

data/mod/05_standard/spec/set/all/error_spec.rb

@@ -2,8 +2,8 @@
 
 describe Card::Set::All::Error do
   describe 'missing view' do
-    it "should prompt to add" do
-      expect(render_content('{{+cardipoo|open}}').match(/Add \<span/ )).not_to be_nil
+    it 'should prompt to add' do
+      expect(render_content('{{+cardipoo|open}}').match(/Add \<span/)).not_to be_nil
     end
   end
-end
+end

data/mod/05_standard/spec/set/all/history_spec.rb

@@ -1,44 +1,44 @@
 # -*- encoding : utf-8 -*-
 describe Card::Set::All::History do
-  context "history view" do
+  context 'history view' do
     # before do
-    #   Card.create! name: "my histoer card"
+    #   Card.create! name: 'my histoer card'
     # end
     it 'should have a frame' do
-      history = render_card :history, name: "A"
+      history = render_card :history, name: 'A'
       assert_view_select history, 'div[class~="card-frame"]'
     end
 
-
     describe '#action_summary' do
       subject do
         first = Card.fetch('First')
         first.format.render_action_summary
       end
       it 'should have a summary' do
-        assert_view_select subject, 'del[class="diffdel diff-red"]', text: 'chicken'
-        assert_view_select subject, 'ins[class="diffins diff-green"]', text: 'chick'
+        assert_view_select subject, 'del[class="diffdel diff-red"]',
+                           text: 'chicken'
+        assert_view_select subject, 'ins[class="diffins diff-green"]',
+                           text: 'chick'
       end
     end
   end
 
-
   describe '#create_act_and_action' do
-    let!(:act_start_cnt) {Card::Act.count}
-    let(:content)        {"Nobody expects the Spanish inquisition"}
-    let(:act)            {@card.acts.last}
-    let(:action)         {act.actions.last}
+    let!(:act_start_cnt) { Card::Act.count }
+    let(:content)        { 'Nobody expects the Spanish inquisition' }
+    let(:act)            { @card.acts.last }
+    let(:action)         { act.actions.last }
 
     context 'for single card' do
       before do
         @card = Card::Auth.as_bot do
-          Card.create name: "single card", content: content
+          Card.create name: 'single card', content: content
         end
       end
 
       context 'when created' do
         it 'adds new act' do
-          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(Card::Act.count).to eq(act_start_cnt + 1)
           expect(act.card_id).to eq(@card.id)
         end
         it 'adds create action' do
@@ -48,12 +48,12 @@ describe Card::Set::All::History do
 
       context 'when updated' do
         it 'adds no act if nothing changed' do
-          @card.update_attributes  name: "single card", content: content
-          expect(Card::Act.count).to eq(act_start_cnt+1)
+          @card.update_attributes  name: 'single card', content: content
+          expect(Card::Act.count).to eq(act_start_cnt + 1)
         end
         it 'adds new act' do
-          @card.update_attributes content: "new content"
-          expect(Card::Act.count).to eq(act_start_cnt+2)
+          @card.update_attributes content: 'new content'
+          expect(Card::Act.count).to eq(act_start_cnt + 2)
         end
       end
 
@@ -64,7 +64,7 @@ describe Card::Set::All::History do
           end
         end
         it 'adds act' do
-          expect(Card::Act.count).to eq(act_start_cnt+2)
+          expect(Card::Act.count).to eq(act_start_cnt + 2)
         end
         it 'adds delete action' do
           expect(action.action_type).to eq(:delete)
@@ -79,7 +79,7 @@ describe Card::Set::All::History do
         it "doesn't create an act" do
           Card::Auth.as(:anonymous) do
             act_count = Card::Act.count
-            Card.create name: "create fail"
+            Card.create name: 'create fail'
             expect(Card::Act.count).to eq act_count
           end
         end
@@ -87,7 +87,7 @@ describe Card::Set::All::History do
         it "doesn't create an action" do
           Card::Auth.as(:anonymous) do
             action_count = Card::Action.count
-            Card.create name: "create fail"
+            Card.create name: 'create fail'
             expect(Card::Action.count).to eq action_count
           end
         end
@@ -96,20 +96,21 @@ describe Card::Set::All::History do
           Card::Auth.as('joe_user') do
             act_count    = Card::Act.count
             action_count = Card::Action.count
-            Card.create name: "crete fail", subcards: {'*all+*create'=>''}
+            Card.create name: 'crete fail', subcards: { '*all+*create' => '' }
             expect(Card::Action.count).to eq action_count
             expect(Card::Act.count).to eq act_count
           end
         end
-
-
       end
     end
 
     context 'for subcard' do
       before do
         Card::Auth.as_bot do
-          @card = Card.create name: "left", subcards: {"+right" =>{ content: content}}
+          content = 'Nobody expects the Spanish inquisition'
+          @card = Card.create! name: 'left',
+                               subcards: { '+right' => { content: content } }
+          act = @card.acts.last
           @left_action = act.actions[0]
           @right_action = act.actions[2]
           @plus_action = act.actions[1]
@@ -118,27 +119,30 @@ describe Card::Set::All::History do
 
       context 'when created' do
         it 'adds only a act for left card' do
-          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(Card::Act.count).to eq(act_start_cnt + 1)
           expect(act.card).to eq(@card)
         end
 
         it 'adds three actions' do
+          act = @card.acts.last
           expect(act.actions.size).to eq(3)
         end
         it 'adds action for left part of type create' do
-          expect(@left_action.card.name).to eq("left")
+          expect(@left_action.card.name).to eq('left')
           expect(@left_action.action_type).to eq(:create)
         end
         it 'adds action for right part of type create' do
-          expect(@right_action.card.name).to eq("right")
+          expect(@right_action.card.name).to eq('right')
           expect(@right_action.action_type).to eq(:create)
         end
         it 'adds action for plus card of type create' do
-          expect(@plus_action.card.name).to eq("left+right")
+          expect(@plus_action.card.name).to eq('left+right')
           expect(@plus_action.action_type).to eq(:create)
         end
         it 'adds content change' do
-          expect(@plus_action.card_changes.find_by_field_name(:db_content).value).to eq(content)
+          changed_content =
+            @plus_action.card_changes.find_by_field_name(:db_content).value
+          expect(changed_content).to eq(content)
         end
         it 'adds superaction for plus card' do
           expect(@plus_action.super_action_id).to eq(@left_action.id)
@@ -147,16 +151,22 @@ describe Card::Set::All::History do
 
       context 'when updated' do
         it 'adds act for left card' do
-          @card.update_attributes subcards: {"+right"=>{content: "New content", db_content: "New Content"}}
-          expect(Card::Act.count).to eq(act_start_cnt+2)
+          @card.update_attributes subcards: {
+            '+right' => {
+              content: 'New content', db_content: 'New Content'
+            }
+          }
+          expect(Card::Act.count).to eq(act_start_cnt + 2)
           expect(act.card).to eq(@card)
         end
         it 'adds action for subcard' do
-          @card.update_attributes subcards: {"+right"=>{content: "New Content"}}
+          @card.update_attributes subcards: {
+            '+right' => { content: 'New Content' }
+          }
           act = @card.acts.last
           expect(act.actions.count).to eq(1)
           expect(act.actions.last.action_type).to eq(:update)
-          expect(act.actions.last.card.name).to eq("left+right")
+          expect(act.actions.last.card.name).to eq('left+right')
         end
       end
     end
@@ -164,7 +174,9 @@ describe Card::Set::All::History do
     context 'for plus card' do
       before do
         Card::Auth.as_bot do
+          content = 'Nobody expects the Spanish inquisition'
           @card = Card.create name: 'left+right', content: content
+          act = @card.acts.last
           @left_action = act.actions[1]
           @plus_action = act.actions[0]
           @right_action = act.actions[2]
@@ -173,29 +185,31 @@ describe Card::Set::All::History do
 
       context 'adds' do
         it 'only a act for plus card' do
-          expect(Card::Act.count).to eq(act_start_cnt+1)
+          expect(Card::Act.count).to eq(act_start_cnt + 1)
           expect(act.card_id).to eq(@card.id)
         end
         it 'three actions' do
+          act = @card.acts.last
           expect(act.actions.size).to eq(3)
         end
         it 'action for left part of type create' do
-          expect(@left_action.card.name).to eq("left")
+          expect(@left_action.card.name).to eq('left')
           expect(@left_action.action_type).to eq(:create)
         end
         it 'superaction for left part' do
           expect(@left_action.super_action_id).to eq(@plus_action.id)
         end
         it 'action for right part of type create' do
-          expect(@right_action.card.name).to eq("right")
+          expect(@right_action.card.name).to eq('right')
           expect(@right_action.action_type).to eq(:create)
         end
         it 'action for plus card of type create' do
-          expect(@plus_action.card.name).to eq("left+right")
+          expect(@plus_action.card.name).to eq('left+right')
           expect(@plus_action.action_type).to eq(:create)
         end
         it 'content change' do
-          expect(@plus_action.card_changes(true).find_by_field_name(:db_content).value).to eq(content)
+          expect(@plus_action.card_changes(true)
+            .find_by_field_name(:db_content).value).to eq(content)
         end
       end
     end