card 1.99.6 → 1.100.0

data/tmpsets/set/mod003-core/all/subcards.rb

@@ -0,0 +1,133 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Subcards)
+#
+module Subcards;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/subcards.rb"; end
+def field tag, opts={}
+  Card.fetch name.field(tag), opts
+end
+
+def subcard card_name
+  subcards.card card_name
+end
+
+def subfield field_name
+  subcards.field field_name
+end
+
+def field? tag
+  field(tag) || subfield(tag)
+end
+
+def subcards
+  @subcards ||= Card::Subcards.new self
+end
+
+def subcards?
+  subcards.present?
+end
+
+def expire_subcards
+  subcards.clear
+end
+
+def save_as_subcard!
+  self.only_storage_phase = true
+  save! validate: false
+end
+
+# phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
+# TODO: handle differently in different stages
+def add_subcard name_or_card, args={}
+  subcards.add name_or_card, args
+end
+alias_method :attach_subcard, :add_subcard
+
+def add_subcard! name_or_card, args={}
+  subcard = subcards.add name_or_card, args
+  subcard.director.reset_stage
+  subcard
+end
+alias_method :attach_subcard!, :add_subcard!
+
+# phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
+def attach_subfield name_or_card, args={}
+  subcards.add_field name_or_card, args
+end
+alias_method :add_subfield, :attach_subfield
+
+def attach_subfield! name_or_card, args={}
+  subcard = subcards.add_field name_or_card, args
+  subcard.director.reset_stage
+  subcard
+end
+
+def detach_subcard name_or_card
+  subcards.remove name_or_card
+end
+alias_method :remove_subcard, :detach_subcard
+
+def detach_subfield name_or_card
+  subcards.remove_field name_or_card
+end
+alias_method :remove_subfield, :detach_subfield
+
+def clear_subcards
+  subcards.clear
+end
+
+# ensures subfield is present
+# does NOT override subfield content if already present
+def ensure_subfield field_name, args={}
+  if subfield_present? field_name
+    subfield field_name
+  else
+    add_subfield field_name, args
+  end
+end
+
+def subfield_present? field_name
+  subfield(field_name)&.content&.present?
+end
+
+def deep_clear_subcards
+  subcards.deep_clear
+end
+
+event :handle_subcard_errors do
+  subcards.each do |subcard|
+    subcard.errors.each do |field, err|
+      subcard_error subcard, field, err
+    end
+    subcard.errors.clear
+  end
+end
+
+def subcard_error subcard, field, err
+  err = "#{field} #{err}" unless %i[content abort].member? field
+  errors.add subcard.name.from(name), err
+end
+
+event :reject_empty_subcards, :prepare_to_validate do
+  subcards.each_with_key do |subcard, key|
+    next unless subcard.new? && subcard.unfilled?
+    remove_subcard(key)
+    director.subdirectors.delete(subcard)
+  end
+end
+
+# check when deleting field that left has not also been deleted
+def trashed_left?
+  l = left
+  !l || l.trash
+end
+
+# check when renaming field that it is not actually the same field
+# (eg on a renamed trunk)
+def same_field?
+  (left_id == left_id_before_act) && (right_id == right_id_before_act)
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/subcards.rb ~~

data/tmpsets/set/mod003-core/all/tabs.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Tabs)
+#
+module Tabs;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/tabs.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :tabs do
+    construct_tabs "tabs"
+  end
+
+  def construct_tabs tab_type
+    tabs = { active: {}, paths: {} }
+    voo.items[:view] ||= :content
+    card.each_item_name_with_options(_render_raw) do |name, options|
+      construct_tab tabs, name, options
+    end
+    tabs tabs[:paths], tabs[:active][:name], tab_type: tab_type, load: :lazy do
+      tabs[:active][:content]
+    end
+  end
+
+  def construct_tab tabs, name, explicit_options
+    tab_options = item_view_options explicit_options
+    tabs[:paths][name] = {
+      title: nest(name, view: :title, title: tab_options[:title]),
+      path: nest_path(name, tab_options).html_safe
+    }
+    return unless tabs[:active].empty?
+    tabs[:active] = { name: name, content: nest(name, tab_options) }
+  end
+
+  # def tab_title title, name
+  #   return name unless title
+  #   name.to_name.title title, @context_names
+  # end
+
+  view :pills do
+    construct_tabs "pills"
+  end
+
+  view :tabs_static do
+    construct_static_tabs "tabs"
+  end
+
+  view :pills_static do
+    construct_static_tabs "pills"
+  end
+
+  def construct_static_tabs tab_type
+    tabs = {}
+    card.item_cards.each do |item|
+      tabs[item.name] = nest item, item_view_options(args)
+    end
+    tabs tabs, nil, tab_type: tab_type
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/tabs.rb ~~

data/tmpsets/set/{mod002-core → mod003-core}/all/templating.rb

@@ -1,13 +1,21 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Templating; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/templating.rb ~~
+class Card; module Set; class All
+# Set: All cards (Templating)
+#
+module Templating;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/templating.rb"; end
 
 def is_template?
-  cardname.trait_name? :structure, :default
+  return @is_template unless @is_template.nil?
+
+  @is_template = name.trait_name? :structure, :default
 end
 
 def is_structure?
-  cardname.trait_name? :structure
+  return @is_structure unless @is_structure.nil?
+
+  @is_structure = name.trait_name? :structure
 end
 
 def template
@@ -24,11 +32,15 @@ def template
   end
 end
 
+def default_type_id
+  Card.default_type_id
+end
+
 def new_card_template
   default = rule_card :default, skip_modules: true
 
   dup_card = dup
-  dup_card.type_id = default ? default.type_id : Card.default_type_id
+  dup_card.type_id = default&.type_id || default_type_id
 
   if (structure = dup_card.structure_rule_card)
     @virtual = true if junction?
@@ -48,10 +60,9 @@ def assigns_type?
   # needed because not all *structure templates govern the type of set members
   # for example, X+*type+*structure governs all cards of type X,
   # but the content rule does not (in fact cannot) have the type X.
-  return unless (set_pattern = Card.fetch cardname.trunk_name.tag_name,
-                                          skip_modules: true)
-  return unless (pattern_code = set_pattern.codename)
-  return unless (set_class = Set::Pattern.find pattern_code)
+  pattern_code = Card.quick_fetch(name.trunk_name.tag_name)&.codename
+  return unless pattern_code && (set_class = Set::Pattern.find pattern_code)
+
   set_class.assigns_type
 end
 
@@ -60,19 +71,10 @@ def structure
   template
 end
 
-def virtual?
-  return false unless new_card?
-  if @virtual.nil?
-    cardname.simple? ? (@virtual = false) : template
-  end
-  @virtual
-end
-
 def structure_rule_card
-  card = rule_card :structure, skip_modules: true
-  card && card.db_content.strip == "_self" ? nil : card
-end
+  return unless (card = rule_card :structure, skip_modules: true)
 
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/templating.rb ~~
+  card.db_content&.strip == "_self" ? nil : card
+end
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/templating.rb ~~

data/tmpsets/set/mod003-core/all/trash.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Trash)
+#
+module Trash;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/trash.rb"; end
+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: "empty trash",
+    task: "empty_trash"
+  }
+)
+
+module ClassMethods
+  def empty_trash
+    Card.delete_trashed_files
+    Card.where(trash: true).in_batches.update_all(left_id: nil, right_id: nil)
+    Card.where(trash: true).in_batches.delete_all
+    Card::Action.delete_cardless
+    Card::Change.delete_actionless
+    Card::Act.delete_actionless
+    Card::Reference.unmap_if_referee_missing
+    Card::Reference.delete_if_referer_missing
+  end
+
+  # deletes any file not associated with a real card.
+  def delete_trashed_files
+    dir = Cardio.paths["files"].existent.first
+    # TODO: handle cloud files
+    return unless dir
+
+    trashed_card_ids = all_trashed_card_ids
+    file_ids = all_file_ids
+    file_ids.each do |file_id|
+      next unless trashed_card_ids.member?(file_id)
+      raise Card::Error, tr(:exception_almost_deleted) if Card.exists?(file_id)
+      ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
+    end
+  end
+
+  def all_file_ids
+    dir = Card.paths["files"].existent.first
+    Dir.entries(dir)[2..-1].map(&:to_i)
+  end
+
+  def all_trashed_card_ids
+    trashed_card_sql = %( select id from cards where trash is true )
+    sql_results = Card.connection.select_all(trashed_card_sql)
+    sql_results.map(&:values).flatten.map(&:to_i)
+  end
+end
+
+def delete args={}
+  add_to_trash args do |delete_args|
+    update delete_args
+  end
+end
+
+def delete! args={}
+  add_to_trash args do |delete_args|
+    update! delete_args
+  end
+end
+
+def add_to_trash args
+  return if new_card?
+  yield args.merge trash: true
+end
+
+event :manage_trash, :prepare_to_store, on: :create do
+  pull_from_trash!
+  self.trash = false
+  true
+end
+
+def pull_from_trash!
+  return unless (self.id = Card::Lexicon.id key)
+
+  # following is needed so that #id_in_database returns existing card id
+  # (and record is updated correctly)
+  db_attributes["id"] = Card.find(id).db_attributes["id"]
+
+  @from_trash = true
+  @new_record = false
+end
+
+def db_attributes
+  send(:mutations_from_database).send :attributes
+end
+
+event :validate_delete, :validate, on: :delete do
+  unless codename.blank?
+    errors.add :delete, tr(:error_system_card, name: name, codename: codename)
+  end
+
+  undeletable_all_rules_tags =
+    %w[default style layout create read update delete]
+  # FIXME: HACK! should be configured in the rule
+
+  if junction? && left&.codename == :all &&
+     undeletable_all_rules_tags.member?(right.codename.to_s)
+    errors.add :delete, tr(:error_indestructible, name: name)
+  end
+
+  errors.add :delete, tr(:error_user_edits, name: name) if account && has_edits?
+end
+
+event :validate_delete_children, after: :validate_delete, on: :delete do
+  return if errors.any?
+  each_child do |child|
+    next unless child
+    # prevents errors in cases where a child is deleted prior to this point
+    # and thus is not returned by the fetch in #children
+
+    delete_as_subcard child
+    # next if child.valid?
+    # child.errors.each do |field, message|
+    #   errors.add field, "can't delete #{child.name}: #{message}"
+    # end
+  end
+end
+
+def delete_as_subcard subcard
+  subcard.trash = true
+  add_subcard subcard
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/trash.rb ~~

data/tmpsets/set/mod003-core/all/type.rb

@@ -0,0 +1,70 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Type)
+#
+module Type;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/type.rb"; end
+
+module ClassMethods
+  def default_type_id
+    @@default_type_id ||= Card[:all].fetch(:default, skip_modules: true).type_id
+  end
+end
+
+def type_card
+  return if type_id.nil?
+  Card.quick_fetch type_id.to_i
+end
+
+def type_code
+  Card::Codename[type_id.to_i]
+end
+
+def type_name
+  type_card.try :name
+end
+
+alias_method :type, :type_name
+
+def type_name_or_default
+  type_card.try(:name) || Card.quick_fetch(Card.default_type_id).name
+end
+
+def type_cardname
+  type_card.try :name
+end
+
+def type= type_name
+  self.type_id = Card.fetch_id type_name
+end
+
+def type_id= card_or_id
+  write_card_or_id :type_id, card_or_id
+end
+
+def type_id_from_template
+  return unless name && (t = template)
+  reset_patterns # still necessary even with new template handling?
+  self.type_id = t.type_id
+end
+
+event :validate_type_change, :validate, on: :update, changed: :type_id do
+  if (c = dup) && c.action == :create && !c.valid?
+    errors.add :type, tr(
+      :error_cant_change_errors,
+      name: name, type_id: type_id,
+      error_messages: c.errors.full_messages
+    )
+  end
+end
+
+event :validate_type, :validate, changed: :type_id, on: :save do
+  errors.add :type, tr(:error_no_such_type) unless type_name
+
+  if (rt = structure) && rt.assigns_type? && type_id != rt.type_id
+    errors.add :type, tr(:error_hard_templated, name: name, type_name: rt.type_name)
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/type.rb ~~