card 1.18.6 → 1.19.0

data/spec/lib/card/loader_spec.rb

@@ -1,10 +1,10 @@
 # -*- encoding : utf-8 -*-
 
-# describe Card::Loader do
+# describe Card::Mod::Loader do
 #   # let(:card_double) { double "Card" }
-#   # let(:pat_all_double) { proxy Card::AllSet }
+#   # let(:pat_all_double) { proxy Card::Set::All }
 #   # let(:format_double) { proxy Card::Format }
-#   # let(:html_format_double) { proxy Card::HtmlFormat }
+#   # let(:html_format_double) { proxy Card::Format::HtmlFormat }
 #   # it "should auto-load Card class methods from lib/card and mods" do
 #   #   #xpect(Card).to receive(:load_mods)
 #   #   #

data/spec/lib/card/migration/import_spec.rb

@@ -0,0 +1,72 @@
+describe Card::Migration::Import do
+  def meta_data
+    path = Card::Migration::Import::ImportData::DEFAULT_PATH
+    YAML.load_file(path).deep_symbolize_keys
+  end
+
+  def content_path filename
+    File.join(Card::Migration::Import::ImportData::CARD_CONTENT_DIR, filename)
+  end
+
+  def content_data_file filename
+    File.read content_path filename
+  end
+
+  before(:each) do
+    if File.exist? Card::Migration::Import::ImportData::DEFAULT_PATH
+      FileUtils.rm Card::Migration::Import::ImportData::DEFAULT_PATH
+    end
+    if Dir.exist? Card::Migration::Import::ImportData::CARD_CONTENT_DIR
+      FileUtils.rm_rf Card::Migration::Import::ImportData::CARD_CONTENT_DIR
+    end
+  end
+
+  describe ".add_remote" do
+    it "adds remote to yml file" do
+      Card::Migration::Import.add_remote "test", "url"
+      remotes = meta_data[:remotes]
+      expect(remotes[:test]).to eq "url"
+    end
+  end
+
+  describe ".pull" do
+    it "saves card attributes" do
+      Card::Migration::Import.pull "A"
+      cards = meta_data[:cards]
+      expect(cards).to be_instance_of(Array)
+      expect(cards.first[:name]).to eq "A"
+      expect(cards.first[:type]).to eq "Basic"
+    end
+
+    it "saves card content" do
+      Card::Migration::Import.pull "A"
+      expect(content_data_file("a")).to eq "Alpha [[Z]]"
+    end
+
+    context "called with deep: true" do
+      it "saves nested card" do
+        Card::Migration::Import.pull "B", deep: true
+        expect(content_data_file("z")).to eq "I'm here to be referenced to"
+      end
+
+      it "does not save linked card" do
+        Card::Migration::Import.pull "A", deep: true
+        expect(File.exist?(content_path("z"))).to be_falsey
+      end
+
+      it "saves pointer items" do
+        Card::Migration::Import.pull "Fruit+*type+*create", deep: true
+        expect(File.exist?(content_path("anyone"))).to be_truthy
+      end
+    end
+  end
+
+  describe ".merge" do
+    it "updates card content" do
+      Card::Migration::Import.pull "A"
+      File.write content_path("a"), "test"
+      Card::Migration::Import.merge
+      expect(Card["A"].content).to eq "test"
+    end
+  end
+end

data/spec/lib/card/name_spec.rb

@@ -1,86 +1,86 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Name do
-  describe '#key' do
-    it 'should lowercase and underscore' do
-      expect('This Name'.to_name.key).to eq('this_name')
+  describe "#key" do
+    it "should lowercase and underscore" do
+      expect("This Name".to_name.key).to eq("this_name")
     end
 
-    it 'should remove spaces' do
-      expect('this    Name'.to_name.key).to eq('this_name')
+    it "should remove spaces" do
+      expect("this    Name".to_name.key).to eq("this_name")
     end
 
-    describe 'underscores' do
-      it 'should be treated like spaces' do
-        expect('weird_ combo'.to_name.key).to eq('weird  combo'.to_name.key)
+    describe "underscores" do
+      it "should be treated like spaces" do
+        expect("weird_ combo".to_name.key).to eq("weird  combo".to_name.key)
       end
 
-      it 'should not impede pluralization checks' do
-        expect('Mamas_and_Papas'.to_name.key).to(
-          eq('Mamas and Papas'.to_name.key)
+      it "should not impede pluralization checks" do
+        expect("Mamas_and_Papas".to_name.key).to(
+          eq("Mamas and Papas".to_name.key)
         )
       end
 
-      it 'should be removed when before first word character' do
-        expect('_This Name'.to_name.key).to eq('this_name')
+      it "should be removed when before first word character" do
+        expect("_This Name".to_name.key).to eq("this_name")
       end
     end
 
-    it 'should singularize' do
-      expect('ethans'.to_name.key).to eq('ethan')
+    it "should singularize" do
+      expect("ethans".to_name.key).to eq("ethan")
     end
 
-    it 'should change CamelCase to snake case' do
-      expect('ThisThing'.to_name.key).to eq('this_thing')
+    it "should change CamelCase to snake case" do
+      expect("ThisThing".to_name.key).to eq("this_thing")
     end
 
-    it 'should handle plus cards' do
-      expect('ThisThing+Ethans'.to_name.key).to eq('this_thing+ethan')
+    it "should handle plus cards" do
+      expect("ThisThing+Ethans".to_name.key).to eq("this_thing+ethan")
     end
 
-    it 'should retain * for star cards' do
-      expect('*right'.to_name.key).to eq('*right')
+    it "should retain * for star cards" do
+      expect("*right".to_name.key).to eq("*right")
     end
 
     it "should not singularize double s's" do
-      expect('grass'.to_name.key).to eq('grass')
+      expect("grass".to_name.key).to eq("grass")
     end
 
     it "should not singularize letter 'S'" do
-      expect('S'.to_name.key).to eq('s')
+      expect("S".to_name.key).to eq("s")
     end
 
-    it 'should handle unicode characters' do
-      expect('Mañana'.to_name.key).to eq('mañana')
+    it "should handle unicode characters" do
+      expect("Mañana".to_name.key).to eq("mañana")
     end
 
-    it 'should handle weird initial characters' do
-      expect('__you motha @#$'.to_name.key).to eq('you_motha')
-      expect('?!_you motha @#$'.to_name.key).to eq('you_motha')
+    it "should handle weird initial characters" do
+      expect("__you motha @\#$".to_name.key).to eq("you_motha")
+      expect("?!_you motha @\#$".to_name.key).to eq("you_motha")
     end
 
-    it 'should allow numbers' do
-      expect('3way'.to_name.key).to eq('3way')
+    it "should allow numbers" do
+      expect("3way".to_name.key).to eq("3way")
     end
 
-    it 'internal plurals' do
-      expect('cards hooks label foos'.to_name.key).to eq('card_hook_label_foo')
+    it "internal plurals" do
+      expect("cards hooks label foos".to_name.key).to eq("card_hook_label_foo")
     end
 
-    it 'should handle html entities' do
+    it "should handle html entities" do
       # This no longer takes off the s, is singularize broken now?
-      expect('Jean-françois Noubel'.to_name.key).to(
-        eq('jean_françoi_noubel')
+      expect("Jean-françois Noubel".to_name.key).to(
+        eq("jean_françoi_noubel")
       )
     end
   end
 
-  describe '#url_key' do
-    cardnames = ['GrassCommons.org', 'Oh you @##', "Alice's Restaurant!",
-                 'PB & J', 'Mañana'].map(&:to_name)
+  describe "#url_key" do
+    cardnames = ["GrassCommons.org", "Oh you @##", "Alice's Restaurant!",
+                 "PB & J", "Mañana"].map(&:to_name)
 
     cardnames.each do |cardname|
-      it 'should have the same key as the name' do
+      it "should have the same key as the name" do
         k = cardname.key
         k2 = cardname.url_key
         # warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
@@ -89,205 +89,205 @@ describe Card::Name do
     end
   end
 
-  describe '#valid' do
-    it 'accepts valid names' do
-      expect('this+THAT'.to_name).to be_valid
-      expect('THE*ONE*AND$!ONLY'.to_name).to be_valid
+  describe "#valid" do
+    it "accepts valid names" do
+      expect("this+THAT".to_name).to be_valid
+      expect("THE*ONE*AND$!ONLY".to_name).to be_valid
     end
 
-    it 'rejects invalid names' do
+    it "rejects invalid names" do
       # 'Tes~sd'.to_name.should_not be_valid
-      expect('TEST/DDER'.to_name).not_to be_valid
+      expect("TEST/DDER".to_name).not_to be_valid
     end
 
-    it 'rejects long names' do
+    it "rejects long names" do
       card = Card.new
-      card.name = '1' * 256
+      card.name = "1" * 256
       expect(card).not_to be_valid
     end
   end
 
-  describe '#left_name' do
-    it 'returns nil for non junction' do
-      expect('a'.to_name.left_name).to eq(nil)
+  describe "#left_name" do
+    it "returns nil for non junction" do
+      expect("a".to_name.left_name).to eq(nil)
     end
 
-    it 'returns parent for parent' do
-      expect('a+b+c+d'.to_name.left_name).to eq('a+b+c')
+    it "returns parent for parent" do
+      expect("a+b+c+d".to_name.left_name).to eq("a+b+c")
     end
   end
 
-  describe '#tag_name' do
-    it 'returns last part of plus card' do
-      expect('a+b+c'.to_name.tag).to eq('c')
+  describe "#tag_name" do
+    it "returns last part of plus card" do
+      expect("a+b+c".to_name.tag).to eq("c")
     end
 
-    it 'returns name of simple card' do
-      expect('a'.to_name.tag).to eq('a')
+    it "returns name of simple card" do
+      expect("a".to_name.tag).to eq("a")
     end
   end
 
-  describe '#safe_key' do
-    it 'subs pluses & stars' do
-      expect('Alpha?+*be-ta'.to_name.safe_key).to eq('alpha-Xbe_tum')
+  describe "#safe_key" do
+    it "subs pluses & stars" do
+      expect("Alpha?+*be-ta".to_name.safe_key).to eq("alpha-Xbe_tum")
     end
   end
 
-  describe '#replace_part' do
-    it 'replaces first name part' do
-      expect('a+b'.to_name.replace_part('a', 'x').to_s).to eq('x+b')
+  describe "#replace_part" do
+    it "replaces first name part" do
+      expect("a+b".to_name.replace_part("a", "x").to_s).to eq("x+b")
     end
-    it 'replaces second name part' do
-      expect('a+b'.to_name.replace_part('b', 'x').to_s).to eq('a+x')
+    it "replaces second name part" do
+      expect("a+b".to_name.replace_part("b", "x").to_s).to eq("a+x")
     end
-    it 'replaces two name parts' do
-      expect('a+b+c'.to_name.replace_part('a+b', 'x').to_s).to eq('x+c')
-      expect('a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s).to eq('e+f+c+d')
+    it "replaces two name parts" do
+      expect("a+b+c".to_name.replace_part("a+b", "x").to_s).to eq("x+c")
+      expect("a+b+c+d".to_name.replace_part("a+b", "e+f").to_s).to eq("e+f+c+d")
     end
     it "doesn't replace two part tag" do
-      expect('a+b+c'.to_name.replace_part('b+c', 'x').to_s).to eq('a+b+c')
+      expect("a+b+c".to_name.replace_part("b+c", "x").to_s).to eq("a+b+c")
     end
   end
 
-  describe 'Cardnames star handling' do
-    it 'recognizes star cards' do
-      expect('*a'.to_name.star?).to be_truthy
+  describe "Cardnames star handling" do
+    it "recognizes star cards" do
+      expect("*a".to_name.star?).to be_truthy
     end
 
     it "doesn't recognize star cards with plusses" do
-      expect('*a+*b'.to_name.star?).to be_falsey
+      expect("*a+*b".to_name.star?).to be_falsey
     end
 
-    it 'recognizes rstar cards' do
-      expect('a+*a'.to_name.rstar?).to be_truthy
+    it "recognizes rstar cards" do
+      expect("a+*a".to_name.rstar?).to be_truthy
     end
 
     it "doesn't recognize star cards as rstar" do
-      expect('*a'.to_name.rstar?).to be_falsey
+      expect("*a".to_name.rstar?).to be_falsey
     end
 
     it "doesn't recognize non-star or star left" do
-      expect('*a+a'.to_name.rstar?).to be_falsey
+      expect("*a+a".to_name.rstar?).to be_falsey
     end
   end
 
-  describe 'trait_name?' do
-    it 'returns true for content codename' do
-      expect('bazoinga+*right+*structure'.to_name.trait_name?(:structure)).to(
+  describe "trait_name?" do
+    it "returns true for content codename" do
+      expect("bazoinga+*right+*structure".to_name.trait_name?(:structure)).to(
         be_truthy
       )
     end
 
-    it 'handles arrays' do
+    it "handles arrays" do
       structure =
-        'bazoinga+*right+*structure'.to_name.trait_name?(:structure, :default)
+        "bazoinga+*right+*structure".to_name.trait_name?(:structure, :default)
       expect(structure).to be_truthy
     end
 
-    it 'returns false for non-template' do
-      structure = 'bazoinga+*right+nontent'.to_name.trait_name?(:structure)
+    it "returns false for non-template" do
+      structure = "bazoinga+*right+nontent".to_name.trait_name?(:structure)
       expect(structure).to be_falsey
     end
   end
 
-  describe '#to_absolute' do
-    it 'handles _self, _whole, _' do
-      expect('_self'.to_name.to_absolute('foo')).to eq('foo')
-      expect('_whole'.to_name.to_absolute('foo')).to eq('foo')
-      expect('_'.to_name.to_absolute('foo')).to eq('foo')
+  describe "#to_absolute" do
+    it "handles _self, _whole, _" do
+      expect("_self".to_name.to_absolute("foo")).to eq("foo")
+      expect("_whole".to_name.to_absolute("foo")).to eq("foo")
+      expect("_".to_name.to_absolute("foo")).to eq("foo")
     end
 
-    it 'handles _left' do
-      expect('_left+Z'.to_name.to_absolute('A+B+C')).to eq('A+B+Z')
+    it "handles _left" do
+      expect("_left+Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
     end
 
-    it 'handles white space' do
-      expect('_left + Z'.to_name.to_absolute('A+B+C')).to eq('A+B+Z')
+    it "handles white space" do
+      expect("_left + Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
     end
 
-    it 'handles _right' do
-      expect('_right+bang'.to_name.to_absolute('nutter+butter')).to(
-        eq('butter+bang')
+    it "handles _right" do
+      expect("_right+bang".to_name.to_absolute("nutter+butter")).to(
+        eq("butter+bang")
       )
-      expect('C+_right'.to_name.to_absolute('B+A')).to eq('C+A')
+      expect("C+_right".to_name.to_absolute("B+A")).to eq("C+A")
     end
 
-    it 'handles leading +' do
-      expect('+bug'.to_name.to_absolute('hum')).to eq('hum+bug')
+    it "handles leading +" do
+      expect("+bug".to_name.to_absolute("hum")).to eq("hum+bug")
     end
 
-    it 'handles trailing +' do
-      expect('bug+'.to_name.to_absolute('tracks')).to eq('bug+tracks')
+    it "handles trailing +" do
+      expect("bug+".to_name.to_absolute("tracks")).to eq("bug+tracks")
     end
 
-    it 'handles _(numbers)' do
-      expect('_1'.to_name.to_absolute('A+B+C')).to eq('A')
-      expect('_1+_2'.to_name.to_absolute('A+B+C')).to eq('A+B')
-      expect('_2+_3'.to_name.to_absolute('A+B+C')).to eq('B+C')
+    it "handles _(numbers)" do
+      expect("_1".to_name.to_absolute("A+B+C")).to eq("A")
+      expect("_1+_2".to_name.to_absolute("A+B+C")).to eq("A+B")
+      expect("_2+_3".to_name.to_absolute("A+B+C")).to eq("B+C")
     end
 
-    it 'handles _LLR etc' do
-      expect('_R'.to_name.to_absolute('A+B+C+D+E')).to    eq('E')
-      expect('_L'.to_name.to_absolute('A+B+C+D+E')).to    eq('A+B+C+D')
-      expect('_LR'.to_name.to_absolute('A+B+C+D+E')).to   eq('D')
-      expect('_LL'.to_name.to_absolute('A+B+C+D+E')).to   eq('A+B+C')
-      expect('_LLR'.to_name.to_absolute('A+B+C+D+E')).to  eq('C')
-      expect('_LLL'.to_name.to_absolute('A+B+C+D+E')).to  eq('A+B')
-      expect('_LLLR'.to_name.to_absolute('A+B+C+D+E')).to eq('B')
-      expect('_LLLL'.to_name.to_absolute('A+B+C+D+E')).to eq('A')
+    it "handles _LLR etc" do
+      expect("_R".to_name.to_absolute("A+B+C+D+E")).to    eq("E")
+      expect("_L".to_name.to_absolute("A+B+C+D+E")).to    eq("A+B+C+D")
+      expect("_LR".to_name.to_absolute("A+B+C+D+E")).to   eq("D")
+      expect("_LL".to_name.to_absolute("A+B+C+D+E")).to   eq("A+B+C")
+      expect("_LLR".to_name.to_absolute("A+B+C+D+E")).to  eq("C")
+      expect("_LLL".to_name.to_absolute("A+B+C+D+E")).to  eq("A+B")
+      expect("_LLLR".to_name.to_absolute("A+B+C+D+E")).to eq("B")
+      expect("_LLLL".to_name.to_absolute("A+B+C+D+E")).to eq("A")
     end
 
-    context 'mismatched requests' do
-      it 'returns _self for _left or _right on simple cards' do
-        expect('_left+Z'.to_name.to_absolute('A')).to eq('A+Z')
-        expect('_right+Z'.to_name.to_absolute('A')).to eq('A+Z')
+    context "mismatched requests" do
+      it "returns _self for _left or _right on simple cards" do
+        expect("_left+Z".to_name.to_absolute("A")).to eq("A+Z")
+        expect("_right+Z".to_name.to_absolute("A")).to eq("A+Z")
       end
 
-      it 'handles bogus numbers' do
-        expect('_1'.to_name.to_absolute('A')).to eq('A')
-        expect('_1+_2'.to_name.to_absolute('A')).to eq('A+A')
-        expect('_2+_3'.to_name.to_absolute('A')).to eq('A+A')
+      it "handles bogus numbers" do
+        expect("_1".to_name.to_absolute("A")).to eq("A")
+        expect("_1+_2".to_name.to_absolute("A")).to eq("A+A")
+        expect("_2+_3".to_name.to_absolute("A")).to eq("A+A")
       end
 
-      it 'handles bogus _llr requests' do
-        expect('_R'.to_name.to_absolute('A')).to eq('A')
-        expect('_L'.to_name.to_absolute('A')).to eq('A')
-        expect('_LR'.to_name.to_absolute('A')).to eq('A')
-        expect('_LL'.to_name.to_absolute('A')).to eq('A')
-        expect('_LLR'.to_name.to_absolute('A')).to eq('A')
-        expect('_LLL'.to_name.to_absolute('A')).to eq('A')
-        expect('_LLLR'.to_name.to_absolute('A')).to eq('A')
-        expect('_LLLL'.to_name.to_absolute('A')).to eq('A')
+      it "handles bogus _llr requests" do
+        expect("_R".to_name.to_absolute("A")).to eq("A")
+        expect("_L".to_name.to_absolute("A")).to eq("A")
+        expect("_LR".to_name.to_absolute("A")).to eq("A")
+        expect("_LL".to_name.to_absolute("A")).to eq("A")
+        expect("_LLR".to_name.to_absolute("A")).to eq("A")
+        expect("_LLL".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLR".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLL".to_name.to_absolute("A")).to eq("A")
       end
     end
 
-    it 'does session user substitution' do
-      expect('_user'.to_name.to_absolute('A')).to eq(Card::Auth.current.name)
+    it "does session user substitution" do
+      expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
       Card::Auth.as_bot do
-        expect('_user'.to_name.to_absolute('A')).to eq(Card::Auth.current.name)
+        expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
       end
     end
   end
 
-  describe '#to_show' do
-    it 'ignores ignorables' do
-      expect('you+awe'.to_name.to_show('you')).to eq('+awe')
+  describe "#to_show" do
+    it "ignores ignorables" do
+      expect("you+awe".to_name.to_show("you")).to eq("+awe")
       # HMMM..... what should this do?
-      expect('me+you+awe'.to_name.to_show('you')).to eq('me+awe')
-      expect('me+you+awe'.to_name.to_show('me')).to eq('+you+awe')
-      expect('me+you+awe'.to_name.to_show('me', 'you')).to eq('+awe')
-      expect('me+you'.to_name.to_show('me', 'you')).to eq('me+you')
-      expect('?a?+awe'.to_name.to_show('A')).to eq('+awe')
-      expect('+awe'.to_name.to_show).to eq('+awe')
+      expect("me+you+awe".to_name.to_show("you")).to eq("me+awe")
+      expect("me+you+awe".to_name.to_show("me")).to eq("+you+awe")
+      expect("me+you+awe".to_name.to_show("me", "you")).to eq("+awe")
+      expect("me+you".to_name.to_show("me", "you")).to eq("me+you")
+      expect("?a?+awe".to_name.to_show("A")).to eq("+awe")
+      expect("+awe".to_name.to_show).to eq("+awe")
     end
   end
 
-  describe 'part creation' do
-    it 'creates parts' do
+  describe "part creation" do
+    it "creates parts" do
       Card::Auth.as_bot do
-        Card.create name: 'left+right'
+        Card.create name: "left+right"
       end
-      expect(Card.fetch('right')).to be_truthy
+      expect(Card.fetch("right")).to be_truthy
     end
   end
 end