card-mod-edit 0.1

data/set/all/edit_type.rb

@@ -0,0 +1,101 @@
+format :html do
+  view :edit_type, cache: :never, perms: :update do
+    frame do
+      _render_edit_type_form
+    end
+  end
+
+  view :edit_type_form, cache: :never, perms: :update, wrap: :slot do
+    card_form :update, success: edit_type_success do
+      [type_formgroup, render_new_buttons]
+    end
+  end
+
+  def edit_type_success
+    { view: :core }
+  end
+
+  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/set/all/editing.rb

@@ -0,0 +1,91 @@
+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
+      end
+    end
+  end
+
+  view :cardboard, :bridge
+
+  def bridge_parts
+    voo.show! :edit_type_row
+
+    [
+      frame_help,
+      _render_edit_name_row(home_view: :edit_name_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
+      _render_edit_form
+    ]
+  end
+
+  def edit_success
+    # for override
+  end
+
+  def edit_view_hidden
+    # for override
+  end
+
+  view :edit_buttons do
+    button_formgroup do
+      wrap_with "div", class: "d-flex" do
+        [standard_submit_button, edit_cancel_button, delete_button]
+      end
+    end
+  end
+
+  # TODO: add undo functionality
+  view :just_deleted, unknown: true do
+    wrap { "#{render_title} deleted" }
+  end
+
+  view :edit_rules, cache: :never, unknown: true do
+    nest current_set_card, view: :bridge_rules_tab
+  end
+
+  view :edit_structure, cache: :never do
+    return unless card.structure
+
+    nest card.structure_rule_card, view: :edit
+    # FIXME: this stuff:
+    #  slot: {
+    #    cancel_slot_selector: ".card-slot.related-view",
+    #    cancel_path: card.format.path(view: :edit), hide: :edit_toolbar,
+    #    hidden: { success: { view: :open, "slot[subframe]" => true } }
+    #  }
+    # }
+  end
+
+  view :edit_nests, cache: :never do
+    frame do
+      with_nest_mode :edit do
+        multi_card_edit
+      end
+    end
+  end
+
+  # FIXME: - view can recurse.  temporarily turned off
+  #
+  # view :edit_nest_rules, cache: :never do
+  #   return ""#
+  #   view = args[:rule_view] || :field_related_rules
+  #   frame do
+  #     # with_nest_mode :edit do
+  #     nested_fields.map do |name, _options|
+  #       nest Card.fetch(name.to_name.trait(:self)),
+  #            view: :titled, title: name, rule_view: view,
+  #            hide: :set_label, show: :rule_navbar
+  #     end
+  #   end
+  # end
+end

data/set/all/editor.rb

@@ -0,0 +1,56 @@
+
+Self::InputOptions.add_to_basket :options, "text area"
+Self::InputOptions.add_to_basket :options, "text field"
+
+format :html do
+  def input_type
+    voo.input_type.present? ? voo.input_type : input_type_from_rule
+  end
+
+  def input_type_from_rule
+    card.rule(:input_type)&.gsub(/[\[\]]/, "")&.tr(" ", "_")
+  end
+
+  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])
+
+    yield card
+  rescue Card::Error::CodenameNotFound
+    nil
+  end
+
+  view :input, unknown: true do
+    try(input_method(input_type)) ||
+      input_defined_by_card ||
+      send(input_method(default_input_type))
+  end
+
+  def default_input_type
+    :rich_text
+  end
+
+  def rich_text_input
+    send "#{Cardio.config.rich_text_editor || :text_area}_editor_input"
+  end
+
+  def text_area_input
+    text_area :content, rows: 5, class: "d0-card-content",
+                        "data-card-type-code" => card.type_code
+  end
+
+  def text_field_input
+    text_field :content, class: classy("d0-card-content")
+  end
+end

data/set/all/form.rb

@@ -0,0 +1,245 @@
+format :html do
+  # FIELDSET VIEWS
+
+  # 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", input: "name", help: false do
+      raw name_field
+    end
+  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
+    reset_form
+    @in_multi_card_editor = true
+    edit_slot
+  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
+    wrap_with :div, class: classy("form-group") do
+      wrap_with :div, yield
+    end
+  end
+
+  def name_field
+    # value needed because otherwise gets wrong value if there are updates
+    text_field :name, value: card.name, autocomplete: "off"
+  end
+
+  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 [_render_conflict_tracker, _render_input]
+    end
+  end
+
+  # SAMPLE editor view for override
+  # view :input do
+  #   text_area :content, rows: 5, class: "d0-card-content"
+  # end
+
+  def edit_slot
+    case
+    when inline_nests_editor?  then _render_core
+    when multi_card_editor?    then multi_card_edit(true)
+    when in_multi_card_editor? then editor_in_multi_card
+    else                            single_card_edit_field
+    end
+  end
+
+  # test: render nests within a normal rendering of the card's content?
+  # (as opposed to a standardized form)
+  def inline_nests_editor?
+    voo.input_type == :inline_nests
+  end
+
+  # test: are we opening a new multi-card form?
+  def multi_card_editor?
+    voo.structure || voo.edit_structure || # structure configured in voo
+      card.structure ||                    # structure in card rule
+      edit_fields?                         # list of fields in card rule
+  end
+
+  # override and return true to optimize
+  def edit_fields?
+    edit_fields.present?
+  end
+
+  # test: are we already within a multi-card form?
+  def in_multi_card_editor?
+    @in_multi_card_editor.present?
+  end
+
+  def single_card_edit_field
+    if voo.show?(:type_formgroup) || voo.show?(:name_formgroup)
+      _render_content_formgroup # use formgroup for consistency
+    else
+      editor_wrap(:content) { content_field }
+    end
+  end
+
+  def editor_in_multi_card
+    add_junction_class
+    formgroup render_title,
+              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
+    field_configs = edit_field_configs fields_only
+    return structure_link if field_configs.empty?
+
+    field_configs.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
+  def process_edit_fields fields
+    fields.map do |field, opts|
+      field_nest field, opts
+    end.join "\n"
+  end
+  ###
+
+  # If you use subfield cards to render a form for a new card
+  # then the subfield cards should be created on the new card not the existing
+  # card that build the form
+
+  def form
+    @form ||= inherit(:form) || new_form
+  end
+
+  def new_form
+    @form_root = true unless parent&.form_root
+    instantiate_builder(form_prefix, card, {})
+  end
+
+  def reset_form
+    @form = new_form
+  end
+
+  def form_prefix
+    case
+    when explicit_form_prefix          then explicit_form_prefix # configured
+    when simple_form?                  then "card"               # simple form
+    when parent.card.name == card.name then parent.form_prefix   # card nests self
+    else                                    edit_in_form_prefix
+    end
+  end
+
+  def simple_form?
+    form_root? || !form_root || !parent
+  end
+
+  def edit_in_form_prefix
+    "#{parent.form_prefix}[subcards][#{card.name.from form_context.card.name}]"
+  end
+
+  def explicit_form_prefix
+    inherit :explicit_form_prefix
+  end
+
+  def form_context
+    form_root? || !form_root ? self : parent
+  end
+
+  def form_root?
+    @form_root == true
+  end
+
+  def form_root
+    return self if @form_root
+
+    parent ? parent.form_root : nil
+  end
+
+  def card_form action, opts={}
+    @form_root = true
+    hidden = hidden_form_tags action, opts
+    form_for card, card_form_opts(action, opts) do |cform|
+      @form = cform
+      hidden + output(yield(cform))
+    end
+  end
+
+  def hidden_form_tags _action, opts
+    success = opts.delete :success
+    success_tags success
+  end
+
+  # @param action [Symbol] :create or :update
+  # @param opts [Hash] html options
+  # @option opts [Boolean] :redirect (false) if true form is no "slotter"
+  def card_form_opts action, opts={}
+    url, action = card_form_url_and_action action
+    html_opts = card_form_html_opts action, opts
+    form_opts = { url: url, html: html_opts }
+    form_opts[:remote] = true unless html_opts.delete(:redirect)
+    form_opts
+  end
+
+  def card_form_html_opts action, opts={}
+    add_class opts, "card-form"
+    add_class opts, "slotter" unless opts[:redirect] || opts[:no_slotter]
+    add_class opts, "autosave" if action == :update
+    opts
+  end
+
+  def card_form_url_and_action action
+    case action
+    when Symbol then [path(action: action), action]
+    when Hash   then [path(action), action[:action]]
+      # for when non-action path args are required
+    else
+      raise Card::Error, "unsupported #card_form_url action: #{action}"
+    end
+  end
+
+  def editor_wrap type=nil
+    html_class = "editor"
+    html_class << " #{type}-editor" if type
+    wrap_with :div, class: html_class do
+      yield
+    end
+  end
+
+  # FIELD VIEWS
+
+  def add_junction_class
+    return unless card.name.junction?
+
+    class_up "card-editor", "RIGHT-#{card.name.tag_name.safe_key}"
+  end
+end