card 1.99.6 → 1.100.0

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

@@ -0,0 +1,143 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (NameEvents)
+#
+# STAGE: prepare to validate
+module NameEvents;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb"; end
+
+event :set_autoname, :prepare_to_validate, on: :create do
+  if name.blank? && (autoname_card = rule_card(:autoname))
+    self.name = autoname autoname_card.db_content
+    # FIXME: should give placeholder in approve phase
+    # and finalize/commit change in store phase
+    autoname_card.refresh.update_column :db_content, name
+  end
+end
+
+# STAGE: validate
+
+event :validate_name, :validate, on: :save, changed: :name do
+  validate_legality_of_name
+  return if errors.any?
+  Card.write_to_soft_cache self
+  validate_uniqueness_of_name
+end
+
+event :validate_uniqueness_of_name, skip: :allowed do
+  # validate uniqueness of name
+
+  return unless (existing_id = Card::Lexicon.id key) && existing_id != id
+  # The above is a fast check but cannot detect if card is in trash
+
+  # TODO: perform the following as a remote-only fetch (not yet supported)
+  return unless (existing_card = Card.where(id: existing_id, trash: false).take)
+
+  errors.add :name, tr(:error_name_exists, name: existing_card.name)
+end
+
+event :validate_legality_of_name do
+  if name.length > 255
+    errors.add :name, tr(:error_too_long, length: name.length)
+  elsif name.blank?
+    errors.add :name, tr(:error_blank_name)
+  elsif name.parts.include? ""
+    errors.add :name, tr(:is_incomplete)
+  elsif !name.valid?
+    errors.add :name, tr(:error_banned_characters, banned: Card::Name.banned_array * " ")
+  elsif changing_existing_tag_to_junction?
+    errors.add :name, tr(:error_name_tag, name: name)
+  end
+end
+
+event :validate_key, after: :validate_name, on: :save do
+  if key.empty?
+    errors.add :key, tr(:error_blank_key) if errors.empty?
+  elsif key != name.key
+    errors.add :key, tr(:error_wrong_key, key: key, name: name)
+  end
+end
+
+# STAGE: store
+
+event :expire_old_name, :store, changed: :name, on: :update do
+  ActManager.expirees << name_before_act
+end
+
+event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
+  Card::Lexicon.add self
+end
+
+event :update_lexicon_on_rename, :finalize, changed: :name, on: :update do
+  Card::Lexicon.update self
+end
+
+def lex
+  simple? ? name : [left_id, right_id]
+end
+
+def old_lex
+  if (old_left_id = left_id_before_act)
+    [old_left_id, right_id_before_act]
+  else
+    name_before_act
+  end
+end
+
+event :prepare_left_and_right, :store, changed: :name, on: :save do
+  return if name.simple?
+  prepare_side :left
+  prepare_side :right
+end
+
+def prepare_side side
+  side_id = send "#{side}_id"
+  sidename = name.send "#{side}_name"
+  prepare_obstructed_side(side, side_id, sidename) ||
+    prepare_new_side(side, side_id, sidename)
+end
+
+def prepare_new_side side, side_id, sidename
+  return unless side_id == -1 || !Card[side_id]&.real?
+
+  sidecard = ActManager.card(sidename) || add_subcard(sidename)
+  send "#{side}_id=", sidecard
+end
+
+def prepare_obstructed_side side, side_id, sidename
+  return unless side_id && side_id == id
+  clear_name sidename
+  send "#{side}_id=", add_subcard(sidename)
+  true
+end
+
+private
+
+def changing_existing_tag_to_junction?
+  return false unless changing_name_to_junction?
+  name_in_use_as_tag?
+end
+
+def name_in_use_as_tag?
+  !Card.where(right_id: id, trash: false).take.nil?
+end
+
+def changing_name_to_junction?
+  name.junction? && simple?
+end
+
+def old_name_in_way? sidecard
+  real? && sidecard&.simple? && id == sidecard&.id
+end
+
+def clear_name name
+  # move the current card out of the way, in case the new name will require
+  # re-creating a card with the current name, ie.  A -> A+B
+  Card.where(id: id).update_all(name: nil, key: nil, left_id: nil, right_id: nil)
+  Card.expire name
+  Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
+  # Card::Lexicon.delete id, key
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~

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

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Observer)
+#
+module Observer;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/observer.rb"; end
+%i[create update delete].each do |action|
+  event "observer_#{action}".to_sym, :integrate, on: action do
+    execute_card_events on: action
+  end
+end
+
+event :cache_delete_card_events, :store, on: :delete do
+  @card_event_cache = event_cards :on_delete
+end
+
+def execute_card_events args
+  setting = "on_#{args[:on]}".to_sym
+  event_cards(setting).each do |event_card|
+    event_card.deliver self
+  end
+end
+
+def event_cards setting
+  @card_event_cache ||
+    ((event_rule = rule_card(setting)) && event_rule.extended_item_cards) ||
+    []
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/observer.rb ~~

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

@@ -0,0 +1,63 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Pattern)
+#
+module Pattern;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb"; end
+def patterns?
+  defined? @patterns
+end
+
+def all_patterns
+  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
+end
+
+# new cards do not
+def patterns
+  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
+end
+
+def reset_patterns
+  # Rails.logger.info "resetting patterns: #{name}"
+  @patterns = @all_patterns = nil
+  @template = @virtual = nil
+  @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
+  @junction_only = nil # only applies to set cards
+  true
+end
+
+def safe_set_keys
+  patterns.map(&:safe_key).reverse * " "
+end
+
+def set_modules
+  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
+end
+
+def set_format_modules klass
+  @set_format_modules ||= {}
+  @set_format_modules[klass] =
+    all_patterns[0..-2].reverse.map do |pattern|
+      pattern.format_module_list klass
+    end.flatten.compact
+end
+
+def set_names
+  @set_names = patterns.map(&:to_s) if @set_names.nil?
+  @set_names
+end
+
+def in_set? set_module
+  patterns.map(&:module_key).include? set_module.shortname
+end
+
+def rule_set_keys
+  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
+end
+
+def include_module? set
+  singleton_class&.include? set
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb ~~

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

@@ -0,0 +1,242 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Permissions)
+#
+module Permissions;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/permissions.rb"; end
+module ClassMethods
+  def repair_all_permissions
+    Card.where("(read_rule_class is null or read_rule_id is null) and trash is false")
+        .each do |broken_card|
+      broken_card.include_set_modules
+      broken_card.repair_permissions!
+    end
+  end
+end
+
+def repair_permissions!
+  rule_id, rule_class = permission_rule_id_and_class :read
+  update_columns read_rule_id: rule_id, read_rule_class: rule_class
+end
+
+# ok? and ok! are public facing methods to approve one action at a time
+#
+#   fetching: if the optional :trait parameter is supplied, it is passed
+#      to fetch and the test is perfomed on the fetched card, therefore:
+#
+#      trait: :account      would fetch this card plus a tag codenamed :account
+#      trait: :roles, new: {} would initialize a new card with default ({})
+# options.
+
+def ok? action
+  @ok ||= {}
+  aok = @ok[Auth.as_id] ||= {}
+  if (cached = aok[action])
+    cached
+  else
+    aok[action] = send "ok_to_#{action}"
+  end
+end
+
+def ok! action
+  raise Card::Error::PermissionDenied, self unless ok? action
+end
+
+def who_can action
+  permission_rule_card(action).item_cards.map(&:id)
+end
+
+def anyone_can? action
+  who_can(action).include? AnyoneID
+end
+
+def direct_rule_card action
+  direct_rule_id = rule_card_id action
+  require_permission_rule! direct_rule_id, action
+  Card.quick_fetch direct_rule_id
+end
+
+def permission_rule_id action
+  if junction? && rule(action).match?(/^\[?\[?_left\]?\]?$/)
+    left_permission_rule_id action
+  else
+    rule_card_id(action)
+  end
+end
+
+def permission_rule_id_and_class action
+  [permission_rule_id(action), direct_rule_card(action).rule_class_name]
+end
+
+def left_permission_rule_id action
+  lcard = left_or_new(skip_virtual: true, skip_modules: true)
+  if action == :create && lcard.real? && lcard.action != :create
+    action = :update
+  end
+  lcard.permission_rule_id action
+end
+
+def permission_rule_card action
+  Card.fetch permission_rule_id(action)
+end
+
+def require_permission_rule! rule_id, action
+  return if rule_id
+  # RULE missing.  should not be possible.
+  # generalize this to handling of all required rules
+  errors.add :permission_denied, tr(:error_no_action_rule, action: action, name: name)
+  raise Card::Error::PermissionDenied, self
+end
+
+def rule_class_name
+  trunk.type_id == SetID ? name.trunk_name.tag : nil
+end
+
+def you_cant what
+  "You don't have permission to #{what}"
+end
+
+def deny_because why
+  @permission_errors << why if @permission_errors
+  false
+end
+
+def permitted? action
+  return false if Card.config.read_only # :read does not call #permit
+  return true if Auth.always_ok?
+
+  Auth.as_card.among? who_can(action)
+end
+
+def permit action, verb=nil
+  # not called by ok_to_read
+  if Card.config.read_only
+    deny_because "Currently in read-only mode"
+    return false
+  end
+
+  return true if permitted? action
+  verb ||= action.to_s
+  deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
+end
+
+def ok_to_create
+  return false unless permit :create
+  return true if simple?
+
+  %i[left right].each do |side|
+    # left is supercard; create permissions will get checked there.
+    next if side == :left && superleft
+    part_card = send side, new: {}
+    # if no card, there must be other errors
+    next unless part_card && part_card.new_card?
+    unless part_card.ok? :create
+      deny_because you_cant("create #{part_card.name}")
+      return false
+    end
+  end
+  true
+end
+
+def ok_to_read
+  return true if Auth.always_ok?
+
+  self.read_rule_id ||= permission_rule_id :read
+  return true if Auth.as_card.read_rules_hash[read_rule_id]
+
+  deny_because you_cant "read this"
+end
+
+def ok_to_update
+  return false unless permit(:update)
+  return true unless type_id_changed? && !permitted?(:create)
+  deny_because you_cant("change to this type (need create permission)")
+end
+
+def ok_to_delete
+  permit :delete
+end
+
+# don't know why we introduced this
+# but we have to preserve read rules to make
+# delete acts visible in recent changes -pk
+# event :clear_read_rule, :store, on: :delete do
+#   self.read_rule_id = self.read_rule_class = nil
+# end
+
+event :set_read_rule, :store,
+      on: :save, changed: %i[type_id name] do
+  read_rule_id, read_rule_class = permission_rule_id_and_class(:read)
+  self.read_rule_id = read_rule_id
+  self.read_rule_class = read_rule_class
+end
+
+event :set_field_read_rules,
+      after: :set_read_rule, on: :update, changed: :type_id do
+  # find all cards with me as trunk and update their read_rule
+  # (because of *type plus right)
+  # skip if name is updated because will already be resaved
+
+  each_field_as_bot do |field|
+    field.refresh.update_read_rule
+  end
+end
+
+def update_field_read_rules
+  return unless type_id_changed? || read_rule_id_changed?
+  each_field_as_bot do |field|
+    field.update_read_rule if field.rule(:read) == "_left"
+  end
+end
+
+def each_field_as_bot
+  Auth.as_bot do
+    fields.each { |field| yield field }
+  end
+end
+
+def without_timestamps
+  Card.record_timestamps = false
+  yield
+ensure
+  Card.record_timestamps = true
+end
+
+event :update_read_rule do
+  without_timestamps do
+    reset_patterns # why is this needed?
+    rcard_id, rclass = permission_rule_id_and_class :read
+    # these two are just to make sure vals are correct on current object
+    self.read_rule_id = rcard_id
+    self.read_rule_class = rclass
+    Card.where(id: id).update_all read_rule_id: rcard_id,
+                                  read_rule_class: rclass
+    expire :hard
+    update_field_read_rules
+  end
+end
+
+def add_to_read_rule_update_queue updates
+  @read_rule_update_queue = Array.wrap(@read_rule_update_queue).concat updates
+end
+
+event :check_permissions, :validate do
+  track_permission_errors do
+    ok? action_for_permission_check
+  end
+end
+
+def action_for_permission_check
+  commenting? ? :update : @action
+end
+
+def track_permission_errors
+  @permission_errors = []
+  result = yield
+  @permission_errors.each { |msg| errors.add :permission_denied, msg }
+  @permission_errors = nil
+  result
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/permissions.rb ~~