card 1.91 → 1.92

data/mod/core/set/all/rules.rb

@@ -74,7 +74,7 @@ def is_preference?
     (set = self[0..-3, skip_modules: true]) &&
     set.type_id == Card::SetID &&
     (user = self[-2, skip_modules: true]) &&
-    (user.type_id == Card::UserID || user.codename == "all")
+    (user.type_id == Card::UserID || user.codename == :all)
 end
 
 def rule setting_code, options={}

data/mod/core/set/all/states.rb

@@ -1,3 +1,15 @@
+module ClassMethods
+  def exists? mark
+    card = quick_fetch mark
+    card.present?
+  end
+
+  def known? mark
+    card = fetch mark, skip_modules: true
+    card.present?
+  end
+end
+
 def state
   case
   when !known?     then :unknown

data/mod/core/set/all/trash.rb

@@ -1,11 +1,12 @@
 Self::Admin.add_to_basket(
   :tasks,
   name: :empty_trash,
+  irreversible: true,
   execute_policy: -> { Card.empty_trash },
   stats: {
     title: "trashed cards",
     count: -> { Card.where(trash: true) },
-    link_text: "delete all",
+    link_text: "empty trash",
     task: "empty_trash"
   }
 )
@@ -84,8 +85,8 @@ event :validate_delete, :validate, on: :delete do
     %w[default style layout create read update delete]
   # FIXME: HACK! should be configured in the rule
 
-  if junction? && (l = left) && l.codename == "all" &&
-     undeletable_all_rules_tags.member?(right.codename)
+  if junction? && left&.codename == :all &&
+     undeletable_all_rules_tags.member?(right.codename.to_s)
     errors.add :delete, "#{name} is an indestructible rule"
   end
 

data/mod/core/set/all/type.rb

@@ -32,6 +32,10 @@ def type= type_name
   self.type_id = Card.fetch_id type_name
 end
 
+def type_known?
+  type_id.present?
+end
+
 def get_type_id_from_structure
   return unless name && (t = template)
   reset_patterns # still necessary even with new template handling?

data/mod/core/set/all/update_read_rules.rb

@@ -8,7 +8,7 @@ event :update_ruled_cards, :finalize do
     self.class.clear_rule_cache
     set = rule_set
 
-    if right_id == Card::ReadID && (name_changed? || trash_changed?)
+    if right_id == Card::ReadID && (name_is_changing? || trash_is_changing?)
       update_read_ruled_cards set
     end
   end

data/mod/core/spec/set/all/actify_spec.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-describe "act API" do
+RSpec.describe "act API" do
   let(:create_card) { Card.create!(name: "main card") }
   let(:create_card_with_subcards) do
     Card.create name: "main card",
@@ -75,20 +75,21 @@ describe "act API" do
 
   describe "dirty attributes" do
     it "survives to integration phase" do
-      Delayed::Worker.delay_jobs = true
+      #Delayed::Worker.delay_jobs = true
       with_test_events do
         test_event :validate do
           self.content = "new content"
+          changed_attributes
         end
         test_event :integrate do
-          expect(name_changed?).to be_truthy
-          expect(changes["name"]).to eq(["A", "new name"])
-          expect(changes["db_content"]).to eq(["Alpha [[Z]]",  "new content"])
+          expect(name_is_changing?).to be_truthy
+          expect(name_before_act).to eq("A")
+          expect(db_content_before_act).to eq("Alpha [[Z]]")
         end
         test_event :integrate_with_delay do
-          expect(name_changed?).to be_truthy
-          expect(changes["name"]).to eq(["A", "new name"])
-          expect(changes["db_content"]).to eq(["Alpha [[Z]]",  "new content"])
+          expect(name_is_changing?).to be_truthy
+          expect(name_before_act).to eq("A")
+          expect(db_content_before_act).to eq("Alpha [[Z]]")
         end
         Delayed::Worker.new.work_off
         Card["A"].update_attributes! name: "new name"

data/mod/core/spec/set/all/assign_attributes_spec.rb

@@ -1,314 +1,48 @@
 # -*- encoding : utf-8 -*-
 
-module RenameMethods
-  def name_invariant_attributes card
-    {
-      content:     card.content,
-      # updater_id:  card.updater_id,
-      # revisions:   card.actions.count,
-      referers: card.referers.map(&:name).sort,
-      referees:    card.referees.map(&:name).sort,
-      descendants:  card.descendants.map(&:id).sort
-    }
+RSpec.describe Card::Set::All::AssignAttributes do
+  it "assigns attributes" do
+    card = Card.new name: "#name", type: :basic, content: "#content", codename: "#codename"
+    expect(card.attributes).to include(
+      "name" => "#name",
+      "db_content" => "#content",
+      "codename" => "#codename",
+      "type_id" => Card::BasicID
+    )
   end
 
-  def assert_rename card, new_name
-    attrs_before = name_invariant_attributes(card)
-    actions_count_before = card.actions.count
-    card.name = new_name
-    card.update_referers = true
-    card.save!
-    expect(card.actions.count).to eq(actions_count_before + 1)
-    assert_equal attrs_before, name_invariant_attributes(card)
-    assert_equal new_name, card.name
-    assert Card[new_name]
+  it "assigns subcards" do
+    card = Card.new name: "#name", subcards: { "sub" => { content: "subcontent" } }
+    expect(card.subcards.first).to eq "sub"
+    subcard = card.subcard "sub"
+    expect(subcard).to be_a(Card)
+    expect(subcard.content).to eq "subcontent"
   end
 
-  def card name
-    Card[name].refresh || raise("Couldn't find card named #{name}")
+  example "change type attribute", as_bot: true do
+    update "A", type_id: Card::CardtypeID
+    expect(Card["A"].type_code).to eq(:cardtype)
   end
-end
-
-RSpec.describe Card::Set::All::AssignAttributes do
-  include RenameMethods
-
-  describe "set_name" do
-    it "handles case variants" do
-      @c = Card.create! name: "chump"
-      expect(@c.name).to eq("chump")
-      @c.name = "Chump"
-      @c.save!
-      expect(@c.name).to eq("Chump")
-    end
-
-    it "handles changing from plus card to simple" do
-      c = Card.create! name: "four+five"
-      c.name = "nine"
-      c.save!
-      expect(c.name).to eq("nine")
-      expect(c.left_id).to eq(nil)
-      expect(c.right_id).to eq(nil)
-    end
-
-    # FIXME: - following tests more about fetch than set_name.
-    # this spec still needs lots of cleanup
-
-    it "test fetch with new when present" do
-      Card.create!(name: "Carrots")
-      cards_should_be_added 0 do
-        c = Card.fetch "Carrots", new: {}
-        c.save
-        expect(c).to be_instance_of(Card)
-        expect(Card.fetch("Carrots")).to be_instance_of(Card)
-      end
-    end
-
-    it "test_simple" do
-      cards_should_be_added 1 do
-        expect(Card["Boo!"]).to be_nil
-        expect(Card.create(name: "Boo!")).to be_instance_of(Card)
-        expect(Card["Boo!"]).to be_instance_of(Card)
-      end
-    end
-
-    it "test fetch with new when not present" do
-      cards_should_be_added 1 do
-        c = Card.fetch("Tomatoes", new: {})
-        c.save
-        expect(c).to be_instance_of(Card)
-        expect(Card.fetch("Tomatoes")).to be_instance_of(Card)
-      end
-    end
-
-    it "test_create_junction" do
-      cards_should_be_added 3 do
-        pearch = Card.create name: "Peach+Pear", content: "juicy"
-        expect(pearch).to be_instance_of(Card)
-      end
-      expect(Card["Peach"]).to be_instance_of(Card)
-      expect(Card["Pear"]).to be_instance_of(Card)
-      assert_equal "juicy", Card["Peach+Pear"].content
-    end
 
-  private
-
-    def cards_should_be_added number
-      number += Card.all.count
-      yield
-      expect(Card.all.count).to eq(number)
-    end
+  example "create cardtype with codename" do
+    card = Card.create! name: "Foo Type", codename: "foo",
+                        type: "Cardtype"
+    expect(card).to have_type(:cardtype).and have_codename :foo
   end
 
-  describe "renaming" do
-    # FIXME: these tests are TOO SLOW!
-    # 8s against server, 12s from command line.
-    # not sure if it's the card creation or the actual renaming process.
-    # Card#save needs optimized in general.
-    # Can't we just move this data to fixtures?
-
-    it "renaming plus card to its own child" do
-      assert_rename card("A+B"), "A+B+T"
-    end
-
-    it "clears cache for old name" do
-      assert_rename Card["Menu"], "manure"
-      expect(Card["Menu"]).to be_nil
-    end
-
-    it "wipes old references by default" do
-      c = Card["Menu"]
-      c.name = "manure"
-      c.save!
-      expect(Card["manure"].references_in.size).to eq(0)
-    end
-
-    it "picks up new references" do
-      Card.create name: "kinds of poop", content: "[[manure]]"
-      assert_rename Card["Menu"], "manure"
-      expect(Card["manure"].references_in.size).to eq(2)
-    end
-
-    it "handles name variants" do
-      assert_rename card("B"), "b"
-    end
-
-    it "handles plus cards renamed to simple" do
-      assert_rename card("A+B"), "K"
-    end
-
-    it "handles flipped parts" do
-      assert_rename card("A+B"), "B+A"
+  it "assigns subfields" do
+      card = Card.new name: "#name", subfields: { default: { content: "subcontent" } }
+      expect(card.subcards.first).to eq "name+*default"
+      subcard = card.subfield :default
+      expect(subcard).to be_a(Card)
+      expect(subcard.name).to eq "#name+*default"
+      expect(subcard.content).to eq "subcontent"
     end
 
-    it "test_should_error_card_exists" do
-      @t = card "T"
-      @t.name = "A+B"
-      assert !@t.save, "save should fail"
-      assert @t.errors[:name], "has errors on key"
-    end
-
-    it "test_used_as_tag" do
-      @b = card "B"
-      @b.name = "A+D"
-      @b.save
-      assert @b.errors[:name]
-    end
-
-    it "test_update_descendants" do
-      old_names = %w[One+Two One+Two+Three Four+One Four+One+Five]
-      new_names = %w[Uno+Two Uno+Two+Three Four+Uno Four+Uno+Five]
-      card_list = old_names.map { |name| Card[name] }
-
-      assert_equal old_names, card_list.map(&:name)
-      Card["One"].update_attributes! name: "Uno"
-      assert_equal new_names, card_list.map(&:reload).map(&:name)
-    end
-
-    it "test_should_error_invalid_name" do
-      @t = card "T"
-      @t.name = "YT_o~Yo"
-      @t.save
-      assert @t.errors[:name]
-    end
-
-    it "test_simple_to_simple" do
-      assert_rename card("A"), "Alephant"
-    end
-
-    it "test_simple_to_junction_with_create" do
-      assert_rename card("T"), "C+J"
-    end
-
-    it "test_reset_key" do
-      c = Card["Basic Card"]
-      c.name = "banana card"
-      c.save!
-      expect(c.key).to eq("banana_card")
-      expect(Card["Banana Card"]).not_to be_nil
-    end
-
-    it "test_rename_should_not_fail_when_updating_inaccessible_referer" do
-      Card.create! name: "Joe Card", content: "Whattup"
-      Card::Auth.as "joe_admin" do
-        Card.create! name: "Admin Card", content: "[[Joe Card]]"
-      end
-      c = Card["Joe Card"]
-      c.update_attributes! name: "Card of Joe", update_referers: true
-      assert_equal "[[Card of Joe]]", Card["Admin Card"].content
-    end
-
-    it "test_rename_should_update_structured_referer" do
-      Card::Auth.as_bot do
-        c = Card.create! name: "Pit"
-        Card.create! name: "Orange", type: "Fruit", content: "[[Pit]]"
-        Card.create! name: "Fruit+*type+*structure", content: "this [[Pit]]"
-
-        assert_equal "this [[Pit]]", Card["Orange"].raw_content
-        c.update_attributes! name: "Seed", update_referers: true
-        assert_equal "this [[Seed]]", Card["Orange"].raw_content
-      end
-    end
-
-    it "handles plus cards that have children" do
-      Card::Auth.as_bot do
-        Card.create name: "a+b+c+d"
-        ab = Card["a+b"]
-        assert_rename ab, "e+f"
-      end
-    end
-
-    context "chuck" do
-      before do
-        Card::Auth.as_bot do
-          Card.create! name: "chuck_wagn+chuck"
-        end
-      end
-
-      it "test_rename_name_substitution" do
-        c1 = Card["chuck_wagn+chuck"]
-        c2 = Card["chuck"]
-        assert_rename c2, "buck"
-        assert_equal "chuck_wagn+buck", Card.find(c1.id).name
-      end
-
-      it "test_reference_updates_plus_to_simple" do
-        c1 = Card::Auth.as_bot do
-          Card.create! name: "Huck", content: "[[chuck wagn+chuck]]"
-        end
-        c2 = Card["chuck_wagn+chuck"]
-        assert_rename c2, "schmuck"
-        c1 = Card.find(c1.id)
-        assert_equal "[[schmuck]]", c1.content
-      end
-    end
-
-    context "dairy" do
-      before do
-        Card::Auth.as_bot do
-          Card.create! name:    "Dairy",
-                       type:    "Cardtype",
-                       content: "[[/new/{{_self|name}}|new]]"
-        end
-      end
-
-      it "test_renaming_card_with_self_link_should_not_hang" do
-        c = Card["Dairy"]
-        c.name = "Buttah"
-        c.update_referers = true
-        c.save!
-        assert_equal "[[/new/{{_self|name}}|new]]", Card["Buttah"].content
-      end
-
-      it "renames card without updating references" do
-        c = Card["Dairy"]
-        c.update_attributes name: "Newt", update_referers: false
-        assert_equal "[[/new/{{_self|name}}|new]]", Card["Newt"].content
-      end
-    end
-
-    context "blues" do
-      before do
-        Card::Auth.as_bot do
-          [
-            ["Blue", ""],
-            ["blue includer 1", "{{Blue}}"],
-            ["blue includer 2", "{{blue|closed;other:stuff}}"],
-            ["blue linker 1", "[[Blue]]"],
-            ["blue linker 2", "[[blue]]"]
-          ].each do |name, content|
-            Card.create! name: name, content: content
-          end
-        end
-      end
-
-      it "test_updates_nests_when_renaming" do
-        c1 = Card["Blue"]
-        c2 = Card["blue includer 1"]
-        c3 = Card["blue includer 2"]
-        c1.update_attributes name: "Red", update_referers: true
-        assert_equal "{{Red}}", Card.find(c2.id).content
-        # NOTE these attrs pass through a hash stage that may not preserve order
-        assert_equal "{{Red|closed;other:stuff}}", Card.find(c3.id).content
-      end
-
-      it "test_updates_nests_when_renaming_to_plus" do
-        c1 = Card["Blue"]
-        c2 = Card["blue includer 1"]
-        c1.update_attributes name: "blue includer 1+color",
-                             update_referers: true
-        assert_equal "{{blue includer 1+color}}", Card.find(c2.id).content
-      end
-
-      it "test_reference_updates_on_case_variants" do
-        c1 = Card["Blue"]
-        c2 = Card["blue linker 1"]
-        c3 = Card["blue linker 2"]
-        c1.reload.name = "Red"
-        c1.update_referers = true
-        c1.save!
-        assert_equal "[[Red]]", Card.find(c2.id).content
-        assert_equal "[[Red]]", Card.find(c3.id).content
-      end
+  describe "set specific attributes" do
+    example "file card with set specfic attribute" do
+      card = Card.new name: "empty", type: :file, empty_ok: true
+      expect(card.empty_ok?).to be_truthy
     end
   end
 end