card 1.17.4 → 1.18.0

data/spec/lib/card/success_spec.rb

@@ -22,40 +22,40 @@ describe Card::Success do
       before do
         success_params id: home.id, view: 'closed'
       end
-      it { is_expected.to eq home}
+      it { is_expected.to eq home }
     end
 
     context 'initialized with REDIRECT string' do
       before do
         success_params 'REDIRECT: Home'
       end
-      it { is_expected.to eq home}
+      it { is_expected.to eq home }
     end
 
     context 'initialized with TEXT string' do
       before do
         success_params 'TEXT: Hi'
       end
-      it { is_expected.to eq 'Hi'}
+      it { is_expected.to eq 'Hi' }
     end
 
     context 'initialized with card object' do
       before do
         success_params home
       end
-      it { is_expected.to eq home}
+      it { is_expected.to eq home }
     end
 
     context 'initialized with url' do
       before do
         success_params 'http://wagn.org'
       end
-      it  { is_expected.to eq 'http://wagn.org'}
+      it  { is_expected.to eq 'http://wagn.org' }
     end
   end
 
   describe '#to_url' do
-    subject { @success.to_url}
+    subject { @success.to_url }
     context 'with params' do
       context 'using initilization' do
         before do
@@ -80,7 +80,7 @@ describe Card::Success do
       context 'using <<' do
         before do
           success_params nil
-          @success << { card: home, view: 'closed'}
+          @success << { card: home, view: 'closed' }
         end
         it { is_expected.to eq '/Home?view=closed' }
       end
@@ -89,7 +89,7 @@ describe Card::Success do
       before do
         success_params 'REDIRECT: *previous'
       end
-      it { is_expected.to eq previous}
+      it { is_expected.to eq previous }
     end
   end
 
@@ -102,7 +102,7 @@ describe Card::Success do
 
   describe '#hard_redirect?' do
     it 'true for "REDIRECT: anywhere"' do
-      success_params "REDIRECT: anywhere"
+      success_params 'REDIRECT: anywhere'
       expect(@success.hard_redirect?).to be_truthy
     end
   end
@@ -135,15 +135,13 @@ describe Card::Success do
       expect(@success.params.keys.sort).to eq [:layout, :script, :structure, :view]
     end
     it 'ignores "id", "name", "mark", "card"", target", and "redirect"' do
-      success_params({
-        id: 5,
-        name: 'Home',
-        card: Card['Home'],
-        mark: 'Home',
-        target: 'Home',
-        redirect: false,
-        view: 'View'
-      })
+      success_params(id: 5,
+                     name: 'Home',
+                     card: Card['Home'],
+                     mark: 'Home',
+                     target: 'Home',
+                     redirect: false,
+                     view: 'View')
       expect(@success.params.keys).to eq [:view]
     end
   end

data/spec/lib/card/view_cache_spec.rb

@@ -5,4 +5,4 @@ describe Card::ViewCache do
     Card::Cache.reset_all
     expect(Card::ViewCache.cache.exist? 'testkey').to be_falsey
   end
-end
+end

data/spec/mailers/mailer_spec.rb

@@ -2,7 +2,7 @@
 require 'card/mailer'
 
 describe Card::Mailer do
-  #include ActionMailer::Quoting
+  # include ActionMailer::Quoting
 
   before do
     ActionMailer::Base.deliveries = []
@@ -43,8 +43,6 @@ describe Card::Mailer do
   #   # FIXME: at least two tests should be here, with & w/o attachment.
   # end
 
-
-
   # describe "cardmail" do
   #   before do
   #     Card.gimme "mailtest", content: "test"
@@ -57,8 +55,8 @@ describe Card::Mailer do
   # end
 
   private
-    def encode(subject)
+
+    def encode subject
       quoted_printable(subject, Card::Mailer::CHARSET)
     end
-
 end

data/spec/models/card/cardtype_spec.rb

@@ -6,14 +6,13 @@ class Card
   cattr_accessor :count
 end
 
-describe "Card (Cardtype)" do
-
-  it "should not allow cardtype remove when instances present" do
+describe 'Card (Cardtype)' do
+  it 'should not allow cardtype remove when instances present' do
     Card.create name: 'City', type: 'Cardtype'
     city = Card.fetch('City')
-    c1=Card.create name: 'Sparta', type: 'City'
-    c2=Card.create name: 'Eugene', type: 'City'
-    assert_equal ['Eugene','Sparta'], Card.search(type: 'City').map(&:name).sort
+    c1 = Card.create name: 'Sparta', type: 'City'
+    c2 = Card.create name: 'Eugene', type: 'City'
+    assert_equal %w(Eugene Sparta), Card.search(type: 'City').map(&:name).sort
     assert_raises ActiveRecord::RecordInvalid do
       city.delete!
     end
@@ -21,50 +20,47 @@ describe "Card (Cardtype)" do
     expect(Card['City']).not_to be_nil
   end
 
-  it "remove cardtype" do
+  it 'remove cardtype' do
     Card.create! name: 'County', type: 'Cardtype'
     c = Card['County']
     c.delete
   end
 
-  it "cardtype creation and dynamic cardtype" do
-
-    assert Card.create( name: 'BananaPudding', type: 'Cardtype' ).type_id == Card::Codename[:cardtype]
-    assert_instance_of Card, c=Card.fetch("BananaPudding")
+  it 'cardtype creation and dynamic cardtype' do
+    assert Card.create(name: 'BananaPudding', type: 'Cardtype').type_id == Card::Codename[:cardtype]
+    assert_instance_of Card, c = Card.fetch('BananaPudding')
 
     # you have to have a module to include or it's just a Basic (type_code fielde excepted)
-    cd = Card.create(type: 'banana_pudding',name: "figgy" )
+    cd = Card.create(type: 'banana_pudding', name: 'figgy')
     assert cd.type_name == 'BananaPudding'
     assert Card.find_by_type_id(c.id)
   end
 
-  describe "conversion to cardtype" do
+  describe 'conversion to cardtype' do
     before do
       @card = Card.create!(type: 'Cardtype', name: 'Cookie')
       expect(@card.type_name).to eq('Cardtype')
     end
 
-    it "creates cardtype model and permission" do
+    it 'creates cardtype model and permission' do
       @card.type_id = Card.fetch_id('cookie')
       @card.save!
       expect(@card.type_name).to eq('Cookie')
-      @card=Card['Cookie']
+      @card = Card['Cookie']
       assert_instance_of Card, @card
       expect(@card.type_code).to eq(nil) # :cookie
-      assert_equal 'Cookie', Card.create!( name: 'Oreo', type: 'Cookie' ).type_name
+      assert_equal 'Cookie', Card.create!(name: 'Oreo', type: 'Cookie').type_name
     end
   end
 
-  it "cardtype" do
+  it 'cardtype' do
     Card.all.each do |card|
       assert !card.type_card.nil?
     end
   end
-
 end
 
-
-describe Card, "created without permission" do
+describe Card, 'created without permission' do
   before do
     Card::Auth.current_id = Card::AnonymousID
   end
@@ -72,14 +68,14 @@ describe Card, "created without permission" do
   # FIXME:  this one should pass.  unfortunately when I tried to fix it it started looking like the clean solution
   #  was to rewrite most of the permissions section as simple validations and i decided not to go down that rabbit hole.
   #
-  #it "should not be valid" do
+  # it "should not be valid" do
   #  Card.new( name: 'foo', type: 'Cardtype').valid?.should_not be_true
-  #end
+  # end
 
-  it "should not create a new cardtype until saved" do
-    expect {
-      Card.new( name: 'foo', type: 'Cardtype')
-    }.not_to change(Card, :count)
+  it 'should not create a new cardtype until saved' do
+    expect do
+      Card.new(name: 'foo', type: 'Cardtype')
+    end.not_to change(Card, :count)
   end
 end
 
@@ -109,37 +105,36 @@ describe Card, 'Normal card with descendants' do
   end
 end
 
-describe Card, "New Cardtype" do
+describe Card, 'New Cardtype' do
   before do
     Card::Auth.as_bot do
       @ct = Card.create! name: 'Animal', type: 'Cardtype'
     end
   end
 
-  it "should have create permissions" do
+  it 'should have create permissions' do
     expect(@ct.who_can(:create)).not_to be_nil
   end
 
-  it "its create permissions should be based on Basic" do
+  it 'its create permissions should be based on Basic' do
     expect(@ct.who_can(:create)).to eq(Card['Basic'].who_can(:create))
   end
 end
 
-describe Card, "Wannabe Cardtype Card" do
+describe Card, 'Wannabe Cardtype Card' do
   before do
     Card::Auth.as_bot do
       @card = Card.create! name: 'convertible'
-      @card.type_id=Card::CardtypeID
+      @card.type_id = Card::CardtypeID
       @card.save!
     end
-
   end
-  it "should successfully change its type to a Cardtype" do
+  it 'should successfully change its type to a Cardtype' do
     expect(Card['convertible'].type_code).to eq(:cardtype)
   end
 end
 
-describe Card, "Joe User" do
+describe Card, 'Joe User' do
   before do
     Card::Auth.as_bot do
       @r3 = Card['r3']
@@ -150,31 +145,29 @@ describe Card, "Joe User" do
     @type_names = Card::Auth.createable_types
   end
 
-  it "should not have r3 permissions" do
+  it 'should not have r3 permissions' do
     expect(@ucard.fetch(new: {}, trait: :roles).item_names.member?(@r3.name)).to be_falsey
   end
-  it "should ponder creating a card of Cardtype F, but find that he lacks create permissions" do
+  it 'should ponder creating a card of Cardtype F, but find that he lacks create permissions' do
     expect(Card.new(type: 'Cardtype F').ok?(:create)).to be_falsey
   end
-  it "should not find Cardtype F on its list of createable cardtypes" do
+  it 'should not find Cardtype F on its list of createable cardtypes' do
     expect(@type_names.member?('Cardtype F')).to be_falsey
   end
-  it "should find Basic on its list of createable cardtypes" do
+  it 'should find Basic on its list of createable cardtypes' do
     expect(@type_names.member?('Basic')).to be_truthy
   end
-
 end
 
-
-describe Card, "Cardtype with Existing Cards" do
+describe Card, 'Cardtype with Existing Cards' do
   before do
     @ct = Card['Cardtype F']
   end
-  it "should have existing cards of that type" do
+  it 'should have existing cards of that type' do
     expect(Card.search(type: @ct.name)).not_to be_empty
   end
 
-  it "should raise an error when you try to delete it" do
+  it 'should raise an error when you try to delete it' do
     Card::Auth.as_bot do
       @ct.delete
       expect(@ct.errors[:cardtype]).not_to be_empty
@@ -182,19 +175,15 @@ describe Card, "Cardtype with Existing Cards" do
   end
 end
 
-
 describe Card::Set::Type::Cardtype do
-
-  it "should handle changing away from Cardtype" do
+  it 'should handle changing away from Cardtype' do
     Card::Auth.as_bot do
-      ctg = Card.create! name: "CardtypeG", type: "Cardtype"
+      ctg = Card.create! name: 'CardtypeG', type: 'Cardtype'
       ctg.type_id = Card::BasicID
       ctg.save!
-      ctg = Card["CardtypeG"]
+      ctg = Card['CardtypeG']
       expect(ctg.type_code).to eq(:basic)
-      #ctg.extension.should == nil
+      # ctg.extension.should == nil
     end
   end
 end
-
-

data/spec/models/card/create_spec.rb

@@ -1,82 +1,101 @@
 # -*- encoding : utf-8 -*-
 
-# FIXME this shouldn't be here
-describe Card::Set::Type::Cardtype, ".create with :codename" do
-  it "should work" do
-    expect(Card.create!(name: "Foo Type", codename: "foo", type: 'Cardtype').type_code).to eq(:cardtype)
+# FIXME: this shouldn't be here
+describe Card::Set::Type::Cardtype, '.create with :codename' do
+  it 'should work' do
+    card = Card.create! name: 'Foo Type', codename: 'foo',
+                        type: 'Cardtype'
+    expect(card.type_code).to eq(:cardtype)
   end
 end
 
-
-
-
-describe Card, "created by Card.new " do
+describe Card, 'created by Card.new' do
   before(:each) do
     Card::Auth.as_bot do
-      @c = Card.new name: "New Card", content: "Great Content"
+      @c = Card.new name: 'New Card', content: 'Great Content'
     end
   end
 
-  it "should not override explicit content with default content" do
+  it 'should not override explicit content with default content' do
     Card::Auth.as_bot do
-      Card.create! name: "blue+*right+*default", content: "joe", type: "Pointer"
-      c = Card.new name: "Lady+blue", content: "[[Jimmy]]"
-      expect(c.content).to eq("[[Jimmy]]")
+      Card.create! name: 'blue+*right+*default', content: 'joe', type: 'Pointer'
+      c = Card.new name: 'Lady+blue', content: '[[Jimmy]]'
+      expect(c.content).to eq('[[Jimmy]]')
     end
   end
 end
 
-
-
-describe Card, "created by Card.create with valid attributes" do
+describe Card, 'created by Card.create with valid attributes' do
   before(:each) do
     Card::Auth.as_bot do
-      @b = Card.create name: "New Card", content: "Great Content"
+      @b = Card.create name: 'New Card', content: 'Great Content'
       @c = Card.find(@b.id)
     end
   end
 
-  it "should not have errors"        do expect(@b.errors.size).to eq(0)        end
-  it "should have the right class"   do expect(@c.class).to    eq(Card) end
-  it "should have the right key"     do expect(@c.key).to      eq("new_card")  end
-  it "should have the right name"    do expect(@c.name).to     eq("New Card")  end
-  it "should have the right content" do expect(@c.content).to  eq("Great Content") end
+  it 'does not have errors' do
+    expect(@b.errors.size).to eq(0)
+  end
+  it 'has the right class' do
+    expect(@c.class).to eq(Card)
+  end
+  it 'has the right key'  do
+    expect(@c.key).to eq('new_card')
+  end
+  it 'has the right name' do
+    expect(@c.name).to eq('New Card')
+  end
+  it 'has the right content' do
+    expect(@c.content).to eq('Great Content')
+  end
 
-  it "should have the right content" do
-    @c.db_content == "Great Content"
+  it 'has the right content' do
+    @c.db_content == 'Great Content'
   end
 
-  it "should be findable by name" do
-    expect(Card["New Card"].class).to eq(Card)
+  it 'is findable by name' do
+    expect(Card['New Card'].class).to eq(Card)
   end
 end
 
-
-describe Card, "create junction" do
+describe Card, 'create junction two parts' do
   before(:each) do
-    @c = Card.create! name: "Peach+Pear", content: "juicy"
+    @c = Card.create! name: 'Peach+Pear', content: 'juicy'
   end
 
-  it "should not have errors" do
+  it "doesn't have errors" do
     expect(@c.errors.size).to eq(0)
   end
 
-  it "should create junction card" do
-    expect(Card["Peach+Pear"].class).to eq(Card)
+  it 'creates junction card' do
+    expect(Card['Peach+Pear'].class).to eq(Card)
   end
 
-  it "should create trunk card" do
-    expect(Card["Peach"].class).to eq(Card)
+  it 'creates trunk card' do
+    expect(Card['Peach'].class).to eq(Card)
   end
 
-  it "should create tag card" do
-    expect(Card["Pear"].class).to eq(Card)
+  it 'creates tag card' do
+    expect(Card['Pear'].class).to eq(Card)
   end
 end
 
+describe Card, 'create junction three parts' do
+  it 'creates very left card' do
+    Card.create! name: 'Apple+Peach+Pear', content: 'juicy'
+    expect(Card['Apple'].class).to eq(Card)
+  end
 
-
-describe Card, "types" do
-
+  it 'sets left and right ids' do
+    Card.create! name: 'Sugar+Milk+Flour', content: 'tasty'
+    sugar_milk = Card['Sugar+Milk']
+    sugar_milk_flour = Card['Sugar+Milk+Flour']
+    expect(sugar_milk_flour.left_id).to eq(sugar_milk.id)
+    expect(sugar_milk_flour.right_id).to eq(Card.fetch_id('Flour'))
+    expect(sugar_milk.left_id).to eq(Card.fetch_id('Sugar'))
+    expect(sugar_milk.right_id).to eq(Card.fetch_id('Milk'))
+  end
 end
 
+describe Card, 'types' do
+end