card 1.101.0 → 1.101.5

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

@@ -1,102 +0,0 @@
-RSpec.describe Card::Set::All::Subcards do
-  let(:create_card) { Card.create!(name: "main card") }
-  let(:create_card_with_subcards) do
-    Card.create name: "main card",
-                subcards: { "11" => { subcards: { "111" => "A" } },
-                            "12" => { subcards: { "121" => "A" } } }
-  end
-
-  class Card
-    def __current_trans
-      @current_trans = ActiveRecord::Base.connection.current_transaction
-    end
-
-    def __record_names reset=false
-      trans = @current_trans && !reset ? @current_trans : __current_trans
-      trans.records&.map { |r| r.try :name }&.compact
-    end
-  end
-
-  describe "add subcards" do
-    context "when in integrate stage" do
-      context "with default subcard handling" do
-        it "processes all cards in one transaction" do
-          with_test_events do
-            test_event :validate, on: :create, for: "main card" do
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              expect(__record_names).to eq ["main card", "sub card"]
-            end
-
-            create_card
-          end
-        end
-      end
-
-      context "with delayed jobs" do
-        before { Cardio.delaying! }
-        after { Cardio.delaying! :off }
-
-        context "with serial subcard handling" do
-          it "director.delay! processes subcards in separate transaction" do
-            with_test_events do
-              test_event :validate, on: :create, for: "main card" do
-                sc = add_subcard("sub card")
-                sc.director.delay!
-              end
-
-              test_event :finalize, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq ["main card"]
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :integrate, on: :create, for: "main card" do
-                expect(__record_names(true)).to eq(nil)
-                expect(subcard("sub card").director.stage).to eq nil
-              end
-
-              test_event :finalize, on: :create, for: "sub card" do
-                expect(__record_names(true)).to eq ["sub card"]
-              end
-
-              test_event :integrate_with_delay, on: :create do
-                expect(__record_names(true)).to eq(nil)
-              end
-              create_card
-              expect(Delayed::Worker.new.work_off).to eq [2, 0]
-              expect(Card["sub card"]).to be_instance_of(Card)
-            end
-          end
-        end
-      end
-
-      describe "in integrate_with_delay stage" do
-        it "processes cards not in the same transaction" do
-          with_test_events do
-            test_event :integrate_with_delay, on: :create, for: "main card" do
-              Card.create! name: "sub create card"
-              add_subcard("sub card")
-            end
-
-            test_event :finalize, on: :create, for: "main card" do
-              __current_trans
-            end
-
-            main_card = create_card
-            Delayed::Worker.new.work_off
-
-            expect(main_card.__record_names).to eq ["main card"]
-            expect(Card["sub card"]).to exist
-            expect(Card["sub create card"]).to exist
-
-            act_of_main = main_card.acts.last
-            expect(act_of_main).to eq Card["sub create card"].actions.last.act
-            expect(act_of_main).to eq Card["sub card"].actions.last.act
-          end
-        end
-      end
-    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