card 1.101.0 → 1.101.1

data/config/initializers/uuid_state_file.rb

@@ -1,3 +0,0 @@
-require "uuid"
-# -*- encoding : utf-8 -*-
-UUID.state_file = false if ENV["UUID_STATE_FILE"] == "off"

data/mod/Modfile

@@ -1,4 +0,0 @@
-mod "admin"
-mod "core"
-mod "settings"
-mod "standard"

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

@@ -1,229 +0,0 @@
-require "uuid"
-
-module ClassMethods
-  def uniquify_name name, rename=:new
-    return name unless Card.exists? name
-    uniq_name = generate_alternative_name name
-    return uniq_name unless rename == :old
-    rename!(name, uniq_name)
-    name
-  end
-
-  def generate_alternative_name name
-    uniq_name = "#{name} 1"
-    uniq_name.next! while Card.exists?(uniq_name)
-    uniq_name
-  end
-
-  def rename! oldname, newname
-    Card[oldname].update! name: newname, update_referers: true
-  end
-end
-
-def name
-  @name ||= left_id ? Card::Lexicon.lex_to_name([left_id, right_id]) : super.to_name
-end
-
-def key
-  @key ||= left_id ? name.key : super
-end
-
-def name= newname
-  @name = superize_name newname.to_name
-  self.key = @name.key
-  update_subcard_names @name
-  write_attribute :name, (@name.simple? ? @name.s : nil)
-  assign_side_ids
-  @name
-end
-
-def assign_side_ids
-  if name.simple?
-    self.left_id = self.right_id = nil
-  else
-    assign_side_id :left_id=, :left_name
-    assign_side_id :right_id=, :right_name
-  end
-end
-
-# assigns left_id and right_id based on names.
-# if side card is new, id is temporarily stored as -1
-def assign_side_id side_id_equals, side_name
-  side_id = Card::Lexicon.id(name.send(side_name)) || -1
-  send side_id_equals, side_id
-end
-
-def superize_name cardname
-  return cardname unless @supercard
-
-  @supercard.subcards.rename key, cardname.key
-  update_superleft cardname
-  @supercard.name.relative? ? cardname : cardname.absolute_name(@supercard.name)
-end
-
-def update_superleft cardname
-  @superleft = @supercard if cardname.field_of? @supercard.name
-end
-
-def key= newkey
-  return if newkey == key
-  update_cache_key key do
-    write_attribute :key, (name.simple? ? newkey : nil)
-    @key = newkey
-  end
-  clean_patterns
-  @key
-end
-
-def clean_patterns
-  return unless patterns?
-  reset_patterns
-  patterns
-end
-
-def update_cache_key oldkey
-  yield
-  was_in_cache = Card.cache.soft.delete oldkey
-  Card.write_to_soft_cache self if was_in_cache
-end
-
-def update_subcard_names new_name, name_to_replace=nil
-  return unless @subcards
-  subcards.each do |subcard|
-    update_subcard_name subcard, new_name, name_to_replace if subcard.new?
-  end
-end
-
-def update_subcard_name subcard, new_name, name_to_replace
-  name_to_replace ||= name_to_replace_for_subcard subcard, new_name
-  subcard.name = subcard.name.swap name_to_replace, new_name.s
-  subcard.update_subcard_names new_name, name # needed?  shouldn't #name= trigger this?
-end
-
-def name_to_replace_for_subcard subcard, new_name
-  # if subcard has a relative name like +C
-  # and self is a subcard as well that changed from +B to A+B then
-  # +C should change to A+B+C. #replace doesn't work in this case
-  # because the old name +B is not a part of +C
-  if subcard.name.starts_with_joint? && new_name.parts.first.present?
-    "".to_name
-  else
-    name
-  end
-end
-
-def autoname name
-  if Card.exists?(name) || Director.include?(name)
-    autoname name.next
-  else
-    name
-  end
-end
-
-# FIXME: use delegations and include all name functions
-delegate :simple?, :compound?, :junction?, to: :name
-
-def left *args
-  case
-  when simple?    then nil
-  when superleft then superleft
-  when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
-    nil # prevent recursion when, eg, renaming A+B to A+B+C
-  else
-    Card.fetch name.left, *args
-  end
-end
-
-def right *args
-  Card.fetch(name.right, *args) unless simple?
-end
-
-def [] *args
-  case args[0]
-  when Integer, Range
-    fetch_name = Array.wrap(name.parts[args[0]]).compact.join Card::Name.joint
-    Card.fetch(fetch_name, args[1] || {}) unless simple?
-  else
-    super
-  end
-end
-
-def trunk *args
-  simple? ? self : left(*args)
-end
-
-def tag *args
-  simple? ? self : Card.fetch(name.right, *args)
-end
-
-def left_or_new args={}
-  left(args) || Card.new(args.merge(name: name.left))
-end
-
-# NOTE: for all these helpers, method returns *all* fields/children/descendants.
-# (Not just those current user has permission to read.)
-
-def fields
-  field_ids.map { |id| Card[id] }
-end
-
-def field_names
-  field_ids.map { |id| Card::Name[id] }
-end
-
-def field_ids
-  child_ids :left
-end
-
-def each_child
-  child_ids.each do |id|
-    (child = Card[id]) && yield(child)
-    # check should not be needed (remove after fixing data problems)
-  end
-end
-
-# eg, A+B is a child of A and B
-def child_ids side=nil
-  return [] unless id
-  side ||= name.simple? ? :part : :left_id
-  Auth.as_bot do
-    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
-  end
-end
-
-def each_descendant &block
-  each_child do |child|
-    yield child
-    child.each_descendant(&block)
-  end
-end
-
-def right_id= cardish
-  write_card_or_id :right_id, cardish
-end
-
-def left_id= cardish
-  write_card_or_id :left_id, cardish
-end
-
-def write_card_or_id attribute, cardish
-  when_id_exists(cardish) { |id| write_attribute attribute, id }
-end
-
-def when_id_exists cardish, &block
-  if (card_id = Card.id cardish)
-    yield card_id
-  elsif cardish.is_a? Card
-    with_id_after_store cardish, &block
-  else
-    yield cardish # eg nil
-  end
-end
-
-# subcards are usually saved after super cards;
-# after_store forces it to save the subcard first
-# and callback afterwards
-def with_id_after_store subcard
-  add_subcard subcard
-  subcard.director.after_store { |card| yield card.id }
-end

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

@@ -1,11 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-RSpec.describe Card::Set::All::Name do
-  describe "#each_descendants" do
-    it "finds descendants" do
-      descendants_of_a = []
-      Card["A"].each_descendant { |card| descendants_of_a << card.name }
-      expect(descendants_of_a).to include("A+B+C")
-    end
-  end
-end

data/mod/standard/set/all/rich_html/html_views/info.rb

@@ -1,84 +0,0 @@
-format :html do
-  view :type, unknown: true do
-    link_to_card card.type_card, nil, class: "cardtype"
-  end
-
-  view :change do
-    voo.show :title_link
-    voo.hide :menu
-    wrap do
-      [_render_title,
-       _render_menu,
-       _render_last_action]
-    end
-  end
-
-  view :last_action do
-    act = card.last_act
-    return unless act
-
-    action = act.action_on card.id
-    return unless action
-
-    action_verb =
-      case action.action_type
-      when :create then "added"
-      when :delete then "deleted"
-      else
-        link_to_view :history, "edited", class: "last-edited", rel: "nofollow"
-      end
-
-    %(
-      <span class="last-update">
-        #{action_verb} #{_render_acted_at} ago by
-        #{subformat(card.last_actor)._render_link}
-      </span>
-    )
-  end
-
-  view :type_info do
-    return unless card.type_code != :basic
-
-    wrap_with :span, class: "type-info float-right" do
-      link_to_card card.type_name, nil, class: "navbar-link"
-    end
-  end
-
-  view :view_list do
-    %i[bar box info_bar open closed titled labeled content content_panel].map do |v|
-      wrap_with :p, [content_tag(:h3, v), render(v, show: :menu)]
-    end.flatten.join ""
-  end
-
-  view :demo do
-    frame do
-      [
-        view_select,
-        wrap_with(:div, view_demo, class: "demo-slot")
-      ]
-    end
-  end
-
-  def demo_view
-    Env.params[:demo_view] || :core
-  end
-
-  def view_demo
-    wrap(true) do
-      render demo_view
-    end
-  end
-
-  def view_select
-    card_form :get, success: { view: :demo } do
-      select_tag :demo_view, options_for_select(all_views, demo_view),
-                 class: "_submit-on-select"
-    end
-  end
-
-  def all_views
-    Card::Set::Format::AbstractFormat::ViewDefinition.views
-                                                     .slice(*self.class.ancestors)
-                                                     .values.map(&:keys).flatten.uniq
-  end
-end

data/mod/standard/set/type/cardtype.rb

@@ -1,119 +0,0 @@
-def related_sets with_self=false
-  sets = []
-  sets << ["#{name}+*type", Card::Set::Type.label(name)] if known?
-  sets + super
-end
-
-format :html do
-  view :type, unknown: true do
-    link_to_card card.type_card, nil, class: "cardtype"
-  end
-
-  def type_formgroup args={}
-    if card.cards_of_type_exist?
-      wrap_with :div, tr(:cards_exist, cardname: safe_name)
-    else
-      super
-    end
-  end
-
-  view :add_link do
-    add_link
-  end
-
-  view :add_button do
-    add_link class: "btn btn-secondary"
-  end
-
-  def add_link opts={}
-    voo.title ||= tr(:add_card, cardname: safe_name)
-    link_to render_title, add_link_opts(opts)
-  end
-
-  def add_link_opts opts
-    modal = opts.delete :modal
-    modal = true if modal.nil?
-    opts[:path] = add_path(modal ? :new_in_modal : :new)
-    modal ? modal_link_opts(opts) : opts
-  end
-
-  view :add_url do
-    card_url _render_add_path
-  end
-
-  def add_path view
-    path_args = { mark: card.name }
-    process_voo_params(path_args) if voo.params
-    if view == :new
-      path_args[:action] = :new
-    else
-      path_args[:action] = :type
-      path_args[:view] = view
-    end
-    path path_args
-  end
-
-  # don't cache because it depends on update permission for another card
-  view :configure_link, cache: :never, perms: ->(fmt) { fmt.can_configure? } do
-    configure_link
-  end
-
-  def can_configure?
-    Card.fetch(card, :type, :structure, new: {}).ok? :update
-  end
-
-  view :configure_button, cache: :never, denial: :blank,
-                          perms:  ->(fmt) { fmt.can_configure? } do
-    configure_link "btn btn-secondary"
-  end
-
-  def configure_link css_class=nil
-    return "" unless Card.fetch(card, :type, :structure, new: {}).ok? :update
-
-    voo.title ||= tr(:configure_card, cardname: safe_name.pluralize)
-    title = _render_title
-    link_to_card card, title, path: { view: :bridge, bridge: { tab: :rules_tab },
-                                      set: Card::Name[safe_name, :type] },
-                              class: css_classes("configure-type-link ml-3", css_class)
-  end
-
-  private
-
-  def process_voo_params path_args
-    context = ((@parent&.card) || card).name
-    Rack::Utils.parse_nested_query(voo.params).each do |key, value|
-      value = value.to_name.absolute(context) if value
-      key = key.to_name.absolute(context)
-      path_args[key] = value
-    end
-  end
-end
-
-def cards_of_type_exist?
-  !new_card? && Card.where(trash: false, type_id: id).exists?
-end
-
-def create_ok?
-  Card.new(type_id: id).ok? :create
-end
-
-def was_cardtype?
-  type_id_before_act == Card::CardtypeID
-end
-
-event :check_for_cards_of_type, after: :validate_delete do
-  errors.add :cardtype, tr(:cards_exist, cardname: name) if cards_of_type_exist?
-end
-
-event :check_for_cards_of_type_when_type_changed,
-      :validate, changing: :type, when: :was_cardtype? do
-  if cards_of_type_exist?
-    errors.add :cardtype, tr(:error_cant_alter, name: name_before_act)
-  end
-end
-
-event :validate_cardtype_name, :validate, on: :save, changed: :name do
-  if %r{[<>/]}.match?(name)
-    errors.add :name, tr(:error_invalid_character_in_cardtype, banned: "<, >, /")
-  end
-end