card 1.98.0 → 1.99.1

data/mod/edit/set/all/edit_name.rb

@@ -1,17 +1,15 @@
 format :html do
   # note: depends on js with selector ".edit_name-view .card-form"
   view :edit_name, perms: :update do
-    frame do
-      edit_name_form
-    end
+    frame { name_form }
   end
 
-  # note: depends on js with selector ".edit_name_form-view .card-form"
-  view :edit_name_form, perms: :update, wrap: :slot, cache: :never do
-    edit_name_form :edit_name_row
+  # note: depends on js with selector ".name_form-view .card-form"
+  view :name_form, perms: :update, wrap: :slot, cache: :never do
+    name_form :edit_name_row
   end
 
-  def edit_name_form success_view=nil
+  def name_form success_view=nil
     card_form({ action: :update, id: card.id },
               # "main-success" => "REDIRECT",
               "data-update-origin": "true",

data/mod/edit/set/all/edit_type.rb

@@ -6,23 +6,96 @@ format :html do
   end
 
   view :edit_type_form, cache: :never, perms: :update, wrap: :slot do
-    card_form :update, "data-update-foreign-slot": ".card-slot.edit_content_form-view",
-                       "data-update-origin": "true",
-                       success: edit_type_success do
-      [_render_type_formgroup,
-       edit_type_buttons]
+    card_form :update, success: edit_type_success do
+      [type_formgroup, render_new_buttons]
     end
   end
 
   def edit_type_success
-    # because the content editor can change with a type change
-    # we have to reload the whole edit view
-    { view: :edit_type_row }
+    { view: :core }
   end
 
-  def edit_type_buttons
-    button_formgroup do
-      standard_cancel_button
+  view :edit_type_row do
+    return _render_bridge_type_formgroup if voo.visible?(:type_form) { false }
+
+    edit_row_fixed_width "Type", link_to_card(card.type), :bridge_type_formgroup
+  end
+
+  view :bridge_type_formgroup, unknown: true, wrap: :slot do
+    type_formgroup href: path(mark: card.id,
+                              view: :edit_form,
+                              assign: true,
+                              slot: { show: :type_form }),
+                   class: "live-type-field slotter",
+                   'data-remote': true,
+                   'data-slot-selector': ".card-slot.edit_form-view"
+  end
+
+  view :type_formgroup do
+    type_formgroup
+  end
+
+  def type_formgroup args={}
+    add_class args, "type-field"
+    wrap_type_formgroup do
+      type_field args
+    end
+  end
+
+  def wrap_type_formgroup
+    formgroup "Type", input: "type", class: "type-formgroup", help: false do
+      output [yield, hidden_field_tag(:assign, true)]
+    end
+  end
+
+  def type_field args={}
+    typelist = Auth.createable_types
+    current_type = type_field_current_value args, typelist
+    template.select_tag "card[type]", type_field_options(current_type),
+                        args.merge("data-select2-id": "#{unique_id}-#{Time.now.to_i}")
+  end
+
+  def type_field_options current_type
+    types = grouped_types(current_type)
+
+    if types.size == 1
+      options_for_select types.flatten[1], current_type
+    else
+      grouped_options_for_select types, current_type
+    end
+  end
+
+  def grouped_types current_type
+    groups = Hash.new { |h, k| h[k] = [] }
+    allowed = ::Set.new Auth.createable_types
+    allowed << current_type if current_type
+
+    visible_cardtype_groups.each_pair do |name, items|
+      if name == "Custom"
+        Auth.createable_types.each do |type|
+          groups["Custom"] << type unless ::Card::Set::Self::Cardtype::GROUP_MAP[type]
+        end
+      else
+        items.each do |i|
+          groups[name] << i if allowed.include?(i)
+        end
+      end
+    end
+    groups
+  end
+
+  def visible_cardtype_groups
+    ::Card::Set::Self::Cardtype::GROUP
+  end
+
+  def type_field_current_value args, typelist
+    return if args.delete :no_current_type
+
+    if !card.new_card? && !typelist.include?(card.type_name)
+      # current type should be an option on existing cards,
+      # regardless of create perms
+      typelist.push(card.type_name).sort!
     end
+    card.type_name_or_default
   end
 end

data/mod/edit/set/all/editing.rb

@@ -2,6 +2,7 @@ format :html do
   ###---( TOP_LEVEL (used by menu) NEW / EDIT VIEWS )
   view :bridge, perms: :update, unknown: true, cache: :never, wrap: :bridge do
     with_nest_mode :edit do
+      add_name_context
       voo.show :help
       wrap true, breadcrumb_data("Editing", "edit") do
         bridge_parts
@@ -9,18 +10,21 @@ format :html do
     end
   end
 
+  view :cardboard, :bridge
+
   def bridge_parts
+    voo.show! :edit_type_row
+
     [
+      frame_help,
       _render_edit_name_row(home_view: :edit_name_row),
-      _render_edit_type_row(home_view: :edit_type_row),
       # home_view is necessary for cancel to work correctly.
       # it seems a little strange to have to think about home_view here,
       # but the issue is that something currently has to happen prior to the
       # render to get voo.slot_options to have the write home view in
       # the slot wrap. I think this would probably best be handled as an
       # option to #wrap that triggers a new heir voo
-      frame_help,
-      _render_edit_content_form
+      _render_edit_form
     ]
   end
 

data/mod/edit/set/all/editor.rb

@@ -6,34 +6,47 @@ Self::InputOptions.add_to_basket :options, "text area"
 Self::InputOptions.add_to_basket :options, "text field"
 
 format :html do
-  def editor
-    (c = card.rule(:input)) && c.gsub(/[\[\]]/, "").tr(" ", "_")
+  def input_type
+    voo.input_type.present? ? voo.input_type : input_type_from_rule
   end
 
-  def editor_method editor_type
-    "#{editor_type}_input"
+  def input_type_from_rule
+    card.rule(:input_type)&.gsub(/[\[\]]/, "")&.tr(" ", "_")
   end
 
-  def editor_defined_by_card
-    return unless (editor_card = Card[editor])
+  def input_method input_type
+    "#{input_type}_input"
+  end
+
+  # core view of card is input
+  def input_defined_by_card
+    with_card input_type do |input_card|
+      nest input_card, view: :core
+    end
+  end
+
+  # move somewhere more accessible?
+  def with_card mark
+    return nil unless (card = Card[mark])
 
-    nest editor_card, view: :core
+    yield card
+  rescue Card::Error::CodenameNotFound
+    nil
   end
 
-  view :editor, unknown: true do
-    try(editor_method(editor)) ||
-      editor_defined_by_card ||
-      send(editor_method(default_editor))
+  view :input, unknown: true do
+    try(input_method(input_type)) ||
+      input_defined_by_card ||
+      send(input_method(default_input_type))
   end
 
-  def default_editor
+  def default_input_type
     :rich_text
   end
 
   # overridden by mods that provide rich text editors
   def rich_text_input
-    default_editor = Cardio.config.rich_text_editor || :tinymce
-    send "#{default_editor}_editor_input"
+    send "#{Cardio.config.rich_text_editor || :tinymce}_editor_input"
   end
 
   def text_area_input
@@ -42,6 +55,6 @@ format :html do
   end
 
   def text_field_input
-    text_field :content, class: "d0-card-content"
+    text_field :content, class: classy("d0-card-content")
   end
 end

data/mod/edit/set/all/form.rb

@@ -1,19 +1,20 @@
 format :html do
   # FIELDSET VIEWS
-  view :content_formgroup, cache: :never do
+
+  # sometimes multiple card formgroups, sometimes just one
+  view :content_formgroups, cache: :never do
     wrap_with :fieldset, edit_slot, class: classy("card-editor", "editor")
   end
 
   view :name_formgroup do
-    formgroup "name", editor: "name", help: false do
+    formgroup "Name", input: "name", help: false do
       raw name_field
     end
   end
 
-  view :type_formgroup do
-    wrap_type_formgroup do
-      type_field class: "type-field edit-type-field"
-    end
+  # single card content formgroup, labeled with "Content"
+  view :content_formgroup, unknown: true, cache: :never do
+    wrap_content_formgroup { content_field }
   end
 
   view :edit_in_form, cache: :never, perms: :update, unknown: true do
@@ -22,10 +23,16 @@ format :html do
     edit_slot
   end
 
-  def wrap_type_formgroup
-    formgroup "type", editor: "type", class: "type-formgroup", help: false do
-      yield
-    end
+  view :conflict_tracker, cache: :never, unknown: true do
+    return unless card&.real?
+
+    card.last_action_id_before_edit = card.last_action_id
+    hidden_field :last_action_id_before_edit, class: "current_revision_id"
+  end
+
+  def wrap_content_formgroup
+    formgroup("Content", input: :content, help: false,
+                         class: classy("card-editor")) { yield }
   end
 
   def button_formgroup
@@ -39,75 +46,19 @@ format :html do
     text_field :name, value: card.name, autocomplete: "off"
   end
 
-  def type_field args={}
-    typelist = Auth.createable_types
-    current_type = type_field_current_value args, typelist
-    options = grouped_options_for_select grouped_types(current_type), current_type
-    template.select_tag "card[type]", options, args
-  end
-
-  GROUP = {
-    "Content" => %w[RichText PlainText Phrase Date Number Toggle Markdown File Image URI],
-    "Custom" => [],
-    "Organize" => ["Cardtype", "Search", "List", "Link list", "Pointer",
-                   "Mirror list", "Mirrored list"],
-    "Admin" => ["Layout", "Skin", "User", "Role",
-                "Notification template", "Email template", "Twitter template" ],
-    "Code" => ["HTML", "Json", "CSS", "SCSS", "JavaScript", "CoffeeScript"]
-  }.freeze
-
-  # group for each cardtype: { "RichText => "Content", "Layout" => "Admin", ... }
-  GROUP_MAP = GROUP.each_with_object({}) do |(cat, types), h|
-                types.each { |t| h[t] = cat }
-              end
-
-  def grouped_types current_type
-    groups = Hash.new { |h, k| h[k] = [] }
-    allowed = ::Set.new Auth.createable_types
-    allowed << current_type if current_type
-
-    GROUP.each_pair do |name, items|
-      items.each do |i|
-        groups[name] << i if allowed.include?(i)
-      end
-    end
-    Auth.createable_types.each do |type|
-      groups["Custom"] << type unless GROUP_MAP[type]
-    end
-    groups
-  end
-
-  def type_field_current_value args, typelist
-    return if args.delete :no_current_type
-
-    if !card.new_card? && !typelist.include?(card.type_name)
-      # current type should be an option on existing cards,
-      # regardless of create perms
-      typelist.push(card.type_name).sort!
-    end
-    card.type_name_or_default
-  end
-
-  def content_field skip_rev_id=false
+  def content_field
     with_nest_mode :normal do
       # by changing nest mode to normal, we ensure that editors (eg image
       # previews) can render core views.
-      output [content_field_revision_tracking(skip_rev_id), _render_editor]
+      output [_render_conflict_tracker, _render_input]
     end
   end
 
   # SAMPLE editor view for override
-  # view :editor do
+  # view :input do
   #   text_area :content, rows: 5, class: "d0-card-content"
   # end
 
-  def content_field_revision_tracking skip_rev_id
-    card.last_action_id_before_edit = card.last_action_id
-    return if !card || card.new_card? || skip_rev_id
-
-    hidden_field :last_action_id_before_edit, class: "current_revision_id"
-  end
-
   def edit_slot
     case
     when inline_nests_editor?  then _render_core
@@ -120,7 +71,7 @@ format :html do
   # test: render nests within a normal rendering of the card's content?
   # (as opposed to a standardized form)
   def inline_nests_editor?
-    voo.editor == :inline_nests
+    voo.input_type == :inline_nests
   end
 
   # test: are we opening a new multi-card form?
@@ -142,8 +93,7 @@ format :html do
 
   def single_card_edit_field
     if voo.show?(:type_formgroup) || voo.show?(:name_formgroup)
-      # display content field in formgroup for consistency with other fields
-      formgroup("content", editor: :content, help: false) { content_field }
+      _render_content_formgroup # use formgroup for consistency
     else
       editor_wrap(:content) { content_field }
     end
@@ -152,17 +102,27 @@ format :html do
   def editor_in_multi_card
     add_junction_class
     formgroup render_title,
-              editor: "content", help: true, class: classy("card-editor") do
+              input: "content", help: true, class: classy("card-editor") do
       [content_field, (form.hidden_field(:type_id) if card.new_card?)]
     end
   end
 
   def multi_card_edit fields_only=false
-    nested_cards_for_edit(fields_only).map do |name, options|
+    nested_cards = nested_cards_for_edit(fields_only)
+    return structure_link if nested_cards.empty?
+
+    nested_cards.map do |name, options|
       nest name, options || {}
     end.join "\n"
   end
 
+  def structure_link
+    # LOCALIZE
+    structured = link_to_card card.structure_rule_card, "structured"
+    "<label>Content</label>"\
+    "<p><em>Uneditable; content is #{structured} without nests</em></p>"
+  end
+
   # @param [Hash|Array] fields either an array with field names and/or field
   # cards or a hash with the fields as keys and a hash with nest options as
   # values

data/mod/edit/set/all/form_buttons.rb

@@ -17,7 +17,7 @@ format :html do
   def standard_save_and_close_button opts={}
     close = opts.delete(:close) || :modal
     text = opts[:text] || "Save and Close"
-    add_class opts, "submit-button btn-sm mr-3 _close-#{close}-on-success"
+    add_class opts, "submit-button btn-sm mr-3 _close-on-success"
     add_class opts, "_update-origin" unless opts[:no_origin_update]
     opts.reverse_merge! text: text, "data-cy": "submit-#{close}"
 
@@ -29,8 +29,16 @@ format :html do
     cancel_button args
   end
 
+  def modal_cancel_button
+    modal_close_button "Cancel", situation: "secondary", class: "btn-sm cancel-button"
+  end
+
   def edit_cancel_button
-    modal_close_button "Cancel", situation: "secondary", class: "btn-sm"
+    modal_cancel_button
+  end
+
+  def new_cancel_button
+    modal_cancel_button
   end
 
   def delete_button opts={}
@@ -40,7 +48,8 @@ format :html do
   def delete_button_opts opts={}
     add_class opts,  "slotter btn btn-outline-danger ml-auto btn-sm"
     opts["data-confirm"] = delete_confirm opts
-    opts[:path] = { action: :delete, success: delete_success(opts) }
+    opts[:path] = { action: :delete }
+    opts[:path][:success] = delete_success(opts) unless opts.delete(:no_success)
     opts[:remote] = true
     opts
   end

data/mod/edit/set/all/formgroup.rb

@@ -1,5 +1,5 @@
 format :html do
-  # a formgroup has a label, an editor and help text
+  # a formgroup has a label, an input and help text
   def formgroup title, opts={}, &block
     wrap_with :div, formgroup_div_args(opts[:class]) do
       formgroup_body title, opts, &block
@@ -7,16 +7,16 @@ format :html do
   end
 
   def formgroup_body title, opts, &block
-    label = formgroup_label opts[:editor], title
-    editor_body = editor_wrap opts[:editor], &block
+    label = formgroup_label opts[:input], title
+    editor_body = editor_wrap opts[:input], &block
     help_text = formgroup_help_text opts[:help]
     "#{label}<div>#{help_text} #{editor_body}</div>"
   end
 
-  def formgroup_label editor_type, title
+  def formgroup_label input, title
     return if voo&.hide?(:title) || title.blank?
 
-    label_type = editor_type || :content
+    label_type = input || :content
     form.label label_type, title
   end