card-mod-mirror 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e7b9160a101445c73c8c54a068117118904ff0a54347ef666b8f0a5dfdf9ce8
+  data.tar.gz: ed3a86a1ad65b17d860d8c08be205b60ac6d78406e3e7582d6694a89a4a498a6
+SHA512:
+  metadata.gz: c8d1504824debb0bcb40a696390397c5fa3faa125742abaf6610b1a43af9602ea1f362f48ac95baebb29fbb8648ffffee2c713dfe722eb09571823f967c7ddb2
+  data.tar.gz: '0185f499ace9e7efa11bd1c9156b3355d06e01f4b7c12619b3f70f5b7fe8cc8f93a01f6217c2272a165bec9904cdcfc8239f71c949f19a58c49d4dedebc4caaa'

data/README.md

@@ -0,0 +1,27 @@
+<!--
+# @title README - mod: mirror
+-->
+
+# Mirror mod (experimental)
+
+This mod supports maintaining two lists – a _Mirror_ list and a _Mirrored_ list
+– that, well, mirror each other. This has sometimes been referred to in Decko
+circles as _bidirectionality_
+
+By well-established convention, many card Sharks set up patterns where an
+explicit list (a card whose type is List or Pointer) is used by Searches.
+
+For example, imagine you have two cardtypes: `Beans` and `Colors`. You'd like to
+be able to go to a Bean card and see all the Colors for that Bean, OR go to a
+Color and see all the Beans for that Color. If you use the List/Search pattern,
+then one of these is a List and the other is a Search. Say you decide to make it
+so the Bean has a List of colors. Then you will need to make it so that the
+Color cards have a Search for all the bean lists that refer to that color.
+
+The problem is that only Lists are directly editable. (If you edit a search,
+then you're editing a query, not directly adding to or subtracting from the
+list).
+
+This mod solves that problem by providing two list types that mirror each other.
+Edit one and those changes take effect on the other one.
+

data/set/all/list_changes.rb

@@ -0,0 +1,49 @@
+# -*- encoding : utf-8 -*-
+
+def list_fields
+  Card.search({ left: name, type_id: MirroredListID }, "list fields")
+end
+
+def listed_by_fields
+  Card.search({ left: name, type_id: MirrorListID }, "listed by fields")
+end
+
+def linker_lists
+  Card.search({ type_id: MirroredListID, link_to: name },
+              "lists that link to #{name}")
+end
+
+def codename_list_exist?
+  Card::Codename.exist?(:mirrored_list) && Card::Codename.exist?(:mirror_list)
+end
+
+event :trunk_cardtype_of_a_list_relation_changed, :finalize,
+      changed: :type, on: :update, when: :codename_list_exist? do
+  type_key_was = Card.quick_fetch(type_id_before_act)&.key
+
+  list_fields.each do |card|
+    card.update_listed_by_cache_for card.item_keys, type_key: type_key_was
+    card.update_listed_by_cache_for card.item_keys
+  end
+  listed_by_fields.each &:update_cached_list
+end
+
+event :trunk_name_of_a_list_relation_changed, :finalize,
+      changed: :name, on: :update,
+      when: :codename_list_exist? do
+  list_fields.each do |card|
+    card.update_listed_by_cache_for card.item_keys
+  end
+  listed_by_fields.each &:update_cached_list
+end
+
+event :cardtype_of_list_item_changed, :validate,
+      changed: :type, on: :save,
+      when: :codename_list_exist? do
+  linker_lists.each do |card|
+    next unless card.item_type_id != type_id
+    errors.add(:type,
+               "can't be changed because #{name} " \
+               "is referenced by list card #{card.name}")
+  end
+end

data/set/type/mirror_list.rb

@@ -0,0 +1,93 @@
+include_set Abstract::Pointer
+
+event :validate_listed_by_name, :validate, on: :save, changing: :name do
+  if !compound? || !right || right.type_id != Card::CardtypeID
+    errors.add :name, t(:mirror_cardtype_right)
+  end
+end
+
+event :validate_listed_by_content, :validate,
+      on: :save, changing: :content do
+  item_cards(content: content).each do |item_card|
+    next unless item_card.type_id != right.id
+    errors.add(
+      :content,
+      "#{item_card.name} has wrong cardtype; " \
+      "only cards of type #{name.right} are allowed"
+    )
+  end
+end
+
+event :update_content_in_list_cards, :prepare_to_validate,
+      on: :save, changing: :content do
+  return unless db_content.present?
+  new_items = item_keys(content: db_content)
+  old_items = item_keys(content: old_content)
+  remove_items(old_items - new_items)
+  add_items(new_items - old_items)
+end
+
+def old_content
+  db_content_before_act.present? ? db_content_before_act : content_cache.read(key)
+end
+
+def remove_items items
+  items.each do |item|
+    next unless (lc = list_card item)
+    lc.drop_item name.left
+    subcards.add lc
+  end
+end
+
+def add_items items
+  items.each do |item|
+    if (lc = list_card(item))
+      lc.add_item name.left
+      subcards.add lc
+    else
+      subcards.add(name: [item, left.type_name].cardname,
+                   type: "list",
+                   content: "[[#{name.left}]]")
+    end
+  end
+end
+
+def content_cache
+  Card::Cache[Card::Set::Type::MirrorList]
+end
+
+def content
+  content_cache.fetch(key) do
+    generate_content
+  end
+end
+
+def generate_content
+  listed_by.map do |item|
+    "[[%s]]" % item.to_name.left
+  end.join "\n"
+end
+
+def listed_by
+  Card.search(
+    { type_id: Card::MirroredListID, right: trunk.type_name,
+      left: { type: name.tag }, refer_to: name.trunk, return: :name },
+    "all cards listed by #{name}"
+  )
+end
+
+def update_cached_list
+  if trunk
+    Card::Cache[Card::Set::Type::MirrorList].write key, generate_content
+  else
+    Card::Cache[Card::Set::Type::MirrorList].delete key
+  end
+end
+
+def list_card item
+  Card.fetch item, left.type_name
+end
+
+def unfilled?
+  false
+end

data/set/type/mirrored_list.rb

@@ -0,0 +1,110 @@
+include_set Abstract::Pointer
+
+event :validate_list_name, :validate, on: :save, changed: :name do
+  errors.add :name, t(:mirror_cardtype_right) unless right&.type_id == Card::CardtypeID
+end
+
+event :validate_list_item_type_change, :validate,
+      on: :save, changed: :name do
+  item_cards.each do |item_card|
+    next unless item_card.type_name.key != item_type_name.key
+    errors.add :name, t(:mirror_conflict_item_type)
+  end
+end
+
+event :validate_list_content, :validate,
+      on: :save, changed: :content do
+  item_cards.each do |item_card|
+    next unless item_card.type_name.key != item_type_name.key
+    errors.add :content, t(
+      :mirror_only_type_allowed,
+      cardname: item_card.name,
+      cardtype: name.right
+    )
+  end
+end
+
+event :create_listed_by_cards, :prepare_to_validate,
+      on: :save, changed: :content do
+  item_names.each do |item_name|
+    listed_by_name = "#{item_name}+#{left.type_name}"
+    next if director.main_director.card.key == listed_by_name.to_name.key
+    if !Card[listed_by_name]
+      add_subcard listed_by_name, type_id: Card::MirrorListID
+    else
+      Card[listed_by_name].update_references_out
+    end
+  end
+end
+
+event :update_related_listed_by_card_on_create, :finalize, on: :create do
+  update_listed_by_cache_for item_keys
+end
+
+event :update_related_listed_by_card_on_content_update, :finalize,
+      on: :update, changed: :content do
+  new_items = item_keys
+  changed_items =
+    if db_content_before_act
+      old_items = item_keys(content: db_content_before_act)
+      old_items + new_items - (old_items & new_items)
+    else
+      new_items
+    end
+  update_listed_by_cache_for changed_items
+end
+
+event :update_related_listed_by_card_on_name_and_type_changes, :finalize,
+      on: :update, changed: %i[name type_id] do
+  update_all_items
+end
+
+event :update_related_listed_by_card_on_delete, :finalize,
+      on: :delete, when: :compound? do
+  update_listed_by_cache_for item_keys, type_key: @left_type_key
+end
+
+event :cache_type_key, :store, on: :delete, when: :compound? do
+  @left_type_key = left.type_card.key
+end
+
+def update_all_items
+  current_items = item_keys
+  if db_content_before_act
+    old_items = item_keys(content: db_content_before_act)
+    update_listed_by_cache_for old_items
+  end
+  update_listed_by_cache_for current_items
+end
+
+def update_listed_by_cache_for item_keys, args={}
+  type_key = args[:type_key] || left&.type_card&.key
+  return unless type_key
+
+  item_keys.each do |item_key|
+    key = "#{item_key}+#{type_key}"
+    next unless Card::Cache[Card::Set::Type::MirrorList].exist? key
+    if (card = Card.fetch(key)) && card.left
+      card.update_cached_list
+      card.update_references_out
+    else
+      Card::Cache[Card::Set::Type::MirrorList].delete key
+    end
+  end
+end
+
+def item_type
+  name.right
+end
+
+def item_type_name
+  name.right_name
+end
+
+def item_type_card
+  name.right
+end
+
+def item_type_id
+  right.id
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-mirror
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Philipp Kühl
+- Ethan McCutchen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- set/all/list_changes.rb
+- set/type/mirror_list.rb
+- set/type/mirrored_list.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: mirror
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.28
+signing_key:
+specification_version: 4
+summary: mirror
+test_files: []