card 1.18.6 → 1.19.0

data/mod/05_standard/set/all/rich_html/editing.rb

@@ -1,241 +0,0 @@
-format :html do
-  ###---( TOP_LEVEL (used by menu) NEW / EDIT VIEWS )
-
-  view :new, perms: :create, tags: :unknown_ok do |args|
-    frame_and_form :create, args, 'main-success' => 'REDIRECT' do
-      [
-        _optional_render(:name_formgroup, args),
-        _optional_render(:type_formgroup, args),
-        _optional_render(:content_formgroup, args),
-        _optional_render(:button_formgroup, args)
-      ]
-    end
-  end
-
-  def default_new_args args
-    hidden = args[:hidden] ||= {}
-    hidden[:success] ||= card.rule(:thanks) || '_self'
-    hidden[:card] ||= {}
-
-    args[:optional_help] ||= :show
-
-    default_new_args_for_name_field_or_title args
-    default_new_args_for_type_field args
-    default_new_args_buttons args
-  end
-
-  def default_new_args_for_name_field_or_title args
-    hidden = args[:hidden]
-    if !params[:name_prompt] && !card.cardname.blank?
-      # name is ready and will show up in title
-      hidden[:card][:name] ||= card.name
-    else
-      args[:title] ||= generic_new_card_title
-      # FIXME: - overrides nest args
-      unless card.rule_card :autoname
-        # prompt for name
-        hidden[:name_prompt] = true unless hidden.key? :name_prompt
-        args[:optional_name_formgroup] ||= :show
-      end
-    end
-    args[:optional_name_formgroup] ||= :hide
-  end
-
-  def generic_new_card_title
-    if card.type_id == Card.default_type_id
-      "New #{card.type_name}"
-    else
-      'New'
-    end
-  end
-
-  def default_new_args_for_type_field args
-    if show_type_formgroup?(args)
-      args[:optional_type_formgroup] = :show
-    else
-      args[:hidden][:card][:type_id] ||= card.type_id
-      args[:optional_type_formgroup] = :hide
-    end
-  end
-
-  def show_type_formgroup? args
-    !params[:type] && !args[:type] &&
-      (main? || card.simple? || card.is_template?) &&
-      Card.new(type_id: card.type_id).ok?(:create)
-  end
-
-  def default_new_args_buttons args
-    cancel_path = !main? && path(view: :missing)
-    args[:buttons] ||= [
-      submit_button(class: 'create-submit-button'),
-      cancel_button(class: 'create-cancel-button', href: cancel_path)
-    ].join "\n"
-  end
-
-  view :edit, perms: :update, tags: :unknown_ok do |args|
-    frame_and_form :update, args.reverse_merge(optional_toolbar: :show) do
-      [
-        _optional_render(:content_formgroup, args),
-        _optional_render(:button_formgroup, args)
-      ]
-    end
-  end
-
-  def default_edit_args args
-    args[:optional_help] ||= :show
-    args[:optional_toolbar] ||= :show
-
-    args[:buttons] ||= %(
-      #{submit_button class: 'submit-button'}
-      #{cancel_button href: (args[:cancel_path] || path),
-                      class: 'cancel-button',
-                      'data-slot-selector' => args[:cancel_slot_selector]}
-    )
-  end
-
-  view :edit_name, perms: :update do |args|
-    frame_and_form(
-      { action: :update, id: card.id }, args, 'main-success' => 'REDIRECT'
-    ) do
-      [
-        _render_name_formgroup(args),
-        _optional_render(:confirm_rename, args),
-        _optional_render(:button_formgroup, args)
-      ]
-    end
-  end
-
-  view :confirm_rename do |args|
-    referers = args[:referers]
-    descendants = card.descendants
-    msg = "<h5>Are you sure you want to rename <em>#{card.name}</em>?</h5>"
-    if referers.any? || descendants.any?
-      msg << rename_info(referers, descendants)
-    end
-    alert('warning') { msg }
-  end
-
-  def rename_info referers, descendants
-    effects = []
-    options = ''
-    if descendants.any? # FIXME: count, don't instantiate
-      effects << "automatically alter #{descendants.size} related name(s)."
-    end
-    if referers.any? # FIXME: count, don't instantiate
-      count = referers.size
-      refs = count == 1 ? 'reference' : 'references'
-      effects << "affect at least #{count} #{refs} to \"#{card.name}\""
-      options = 'You may choose to <em>update or ignore</em> the referers.'
-    end
-    effects = effects.map { |effect| "<li>#{effect}</li>" }.join('')
-    "<h6>This change will...</h6><ul>#{effects}</ul><p>#{options}</p>"
-  end
-
-  def default_edit_name_args args
-    referers = args[:referers] = card.family_referers
-    args[:hidden] ||= {}
-    args[:hidden].reverse_merge!(
-      success:  '_self',
-      old_name: card.name,
-      referers: referers.size, # FIXME: count, don't instantiate
-      card:     { update_referers: false }
-    )
-    args[:optional_toolbar] ||= :show
-    args[:buttons] = default_rename_buttons
-  end
-
-  def default_rename_buttons
-    [submit_button(text: 'Rename and Update',
-                   disable_with: 'Renaming',
-                   class: 'renamer-updater'),
-     button_tag('Rename', data: { disable_with: 'Renaming' }, class: 'renamer'),
-     cancel_button(href: path)
-    ].join "\n"
-  end
-
-  view :edit_type, perms: :update do |args|
-    frame_and_form :update, args do
-      # 'main-success'=>'REDIRECT: _self', # adding this back in would make
-      # main cards redirect on cardtype changes
-      [
-        _render_type_formgroup(args),
-        optional_render(:button_formgroup, args)
-      ]
-    end
-  end
-
-  def default_edit_type_args args
-    args[:variety] = :edit # YUCK!
-    args[:optional_toolbar] ||= :show
-    args[:hidden] ||= { success: { view: :edit } }
-    args[:buttons] = [
-      submit_button, cancel_button(href: path(view: :edit))
-    ].join "\n"
-  end
-
-  view :edit_rules, tags: :unknown_ok do |args|
-    view = args[:rule_view] || :common_rules
-    slot_args =
-      {
-        rule_view: view,
-        optional_set_navbar: :show,
-        optional_set_label: :hide,
-        optional_rule_navbar: :hide
-      }
-    _render_related args.merge(
-      related: { card: current_set_card, view: :open, slot: slot_args }
-    )
-  end
-
-  def default_edit_rules_args args
-    args[:optional_toolbar] ||= :show
-  end
-
-  # for backwards compatibility
-  view :options, view: :edit_rules, mod: All::RichHtml::Editing::HtmlFormat
-
-  view :edit_structure do |args|
-    slot_args =
-      {
-        cancel_slot_selector: '.card-slot.related-view',
-        cancel_path: card.format.path(view: :edit),
-        optional_edit_toolbar: :hide,
-        hidden: { success: { view: :open, 'slot[subframe]' => true } }
-      }
-    render_related args.merge(
-      related: { card: card.structure, view: :edit, slot: slot_args }
-    )
-  end
-
-  def default_edit_structure_args args
-    args[:optional_toolbar] ||= :show
-  end
-
-  view :edit_nests do |args|
-    frame args do
-      with_nest_mode :edit do
-        process_nested_fields optional_toolbar: :hide
-      end
-    end
-  end
-  def default_edit_nests_args args
-    args[:optional_toolbar] ||= :show
-  end
-
-  view :edit_nest_rules do |args|
-    view = args[:rule_view] || :field_related_rules
-    frame args do
-      # with_nest_mode :edit do
-      nested_fields(args).map do |chunk|
-        nest Card.fetch("#{chunk.referee_name}+*self"),
-             view: :titled, title: chunk.referee_name, rule_view: view,
-             optional_set_label: :hide,
-             optional_rule_navbar: :show
-      end
-    end
-  end
-
-  def default_edit_nest_rules_args args
-    args[:optional_toolbar] ||= :show
-  end
-end

data/mod/05_standard/set/all/rich_html/form.rb

@@ -1,301 +0,0 @@
-format :html do
-  def edit_slot args={}
-    # note: @mode should already be :edit here...
-    if args[:structure] || card.structure ||
-       args[:edit_fields]
-      multi_card_edit_slot args
-    else
-      single_card_edit_slot args
-    end
-  end
-
-  def multi_card_edit_slot args
-    if args[:core_edit] # need better name
-      _render_core args
-    elsif args[:edit_fields]
-      process_edit_fields args[:edit_fields]
-    else
-      process_nested_fields optional_toolbar: :hide,
-                            structure: args[:structure]
-    end
-  end
-
-  def single_card_edit_slot args
-    field = content_field form, args
-    if [args[:optional_type_formgroup], args[:optional_name_formgroup]]
-       .member? :show
-      # display content field in formgroup for consistency with other fields
-      formgroup '', field, editor: :content
-    else
-      editor_wrap(:content) { field }
-    end
-  end
-
-  def process_nested_fields args
-    nested_fields(args).map do |chunk|
-      nested_card = fetch_nested_card chunk.options
-      nest nested_card, chunk.options.reverse_merge(args)
-    end.join "\n"
-  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|
-      nested_card =
-        if field.is_a?(Card)
-          field
-        else
-          fetch_nested_card inc_name: field
-        end
-      nest nested_card, opts
-    end.join "\n"
-  end
-
-  def form_for_multi
-    instantiate_builder("card#{subcard_input_names}", card, {})
-  end
-
-  def subcard_input_names
-    return '' if !form_root_format || form_root_format == self
-    "#{@parent.subcard_input_names}[subcards][#{card.contextual_name}]"
-  end
-
-  def form
-    @form ||= form_for_multi
-  end
-
-  def card_form action, opts={}
-    @form_root = true
-    hidden_args = opts.delete :hidden
-    form_for card, card_form_opts(action, opts) do |form|
-      @form = form
-      %(
-        #{hidden_tags hidden_args if hidden_args}
-        #{yield form}
-      )
-    end
-  end
-
-  def form_root_format
-    if @form_root
-      self
-    elsif !@parent
-      nil
-    else
-      @parent.form_root_format
-    end
-  end
-
-  def card_form_opts action, html={}
-    url, action = url_from_action(action)
-
-    klasses = Array.wrap(html[:class])
-    klasses << 'card-form slotter'
-    klasses << 'autosave' if action == :update
-    html[:class] = klasses.join ' '
-
-    html[:recaptcha] ||= 'on' if card.recaptcha_on?
-    html.delete :recaptcha if html[:recaptcha] == :off
-
-    { url: url, remote: true, html: html }
-  end
-
-  def url_from_action action
-    case action
-    when Symbol
-      [path(action: action), action]
-    when Hash
-      [path(action), action[:action]]
-    when String # deprecated
-      [card_path(action), nil]
-    else
-      raise Card::Error, "unsupported card_form action class: #{action.class}"
-    end
-  end
-
-  def editor_wrap type=nil
-    html_class = 'editor'
-    html_class << " #{type}-editor" if type
-    content_tag(:div, class: html_class) { yield.html_safe }
-  end
-
-  def formgroup title, content, opts={}
-    wrap_with :div, formgroup_div_args(opts[:class]) do
-      %(
-        #{form.label(opts[:editor] || :content, title)}
-        <div>
-          #{editor_wrap(opts[:editor]) { content }}
-          #{formgroup_help_text opts[:help]}
-        </div>
-      )
-    end
-  end
-
-  def formgroup_div_args html_class
-    div_args = { class: ['form-group', html_class].compact.join(' ') }
-    div_args[:card_id] = card.id if card.real?
-    div_args[:card_name] = h card.name if card.name.present?
-    div_args
-  end
-
-  def formgroup_help_text text=nil
-    case text
-    when String then _render_help help_class: 'help-block', help_text: text
-    when true   then _render_help help_class: 'help-block'
-    end
-  end
-
-  def hidden_tags hash, base=nil
-    # convert hash into a collection of hidden tags
-    result = ''
-    hash ||= {}
-    hash.each do |key, val|
-      result +=
-        if val.is_a?(Hash)
-          hidden_tags val, key
-        else
-          name = base ? "#{base}[#{key}]" : key
-          hidden_field_tag name, val
-        end
-    end
-    result
-  end
-
-  # FIELDSET VIEWS
-
-  view :name_formgroup do |args|
-    formgroup 'name', raw(name_field(form)),
-              editor: 'name', help: args[:help]
-  end
-
-  view :type_formgroup do |args|
-    field = if args[:variety] == :edit # FIXME: dislike this api -ef
-              type_field class: 'type-field edit-type-field'
-            else
-              type_field class: 'type-field live-type-field',
-                         href: path(view: :new), 'data-remote' => true
-            end
-    formgroup 'type', field, editor: 'type', class: 'type-formgroup'
-  end
-
-  view :button_formgroup do |args|
-    %(<div class="form-group"><div>#{args[:buttons]}</div></div>)
-  end
-
-  view :content_formgroup do |args|
-    raw %(
-      <fieldset class="card-editor editor">
-        #{edit_slot args}
-      </fieldset>
-    )
-  end
-
-  def name_field form=nil, options={}
-    form ||= self.form
-    text_field(:name, {
-      # needed because otherwise gets wrong value if there are updates
-      value: card.name,
-      autocomplete: 'off'
-    }.merge(options))
-  end
-
-  def type_field args={}
-    typelist = Auth.createable_types
-    current_type =
-      unless 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
-
-    options = options_from_collection_for_select typelist, :to_s, :to_s,
-                                                 current_type
-    template.select_tag 'card[type]', options, args
-  end
-
-  def content_field form, options={}
-    @form = form
-    @nested = options[:nested]
-    card.last_action_id_before_edit = card.last_action_id
-    revision_tracking =
-      if card && !card.new_card? && !options[:skip_rev_id]
-        hidden_field :last_action_id_before_edit, class: 'current_revision_id'
-        # hidden_field_tag 'card[last_action_id_before_edit]',
-        # card.last_action_id, class: 'current_revision_id'
-      end
-    %(
-      #{revision_tracking}
-      #{_render_editor options}
-    )
-  end
-
-  # FIELD VIEWS
-
-  view :editor do |_args|
-    text_area :content, rows: 3, class: 'tinymce-textarea card-content',
-                        id: unique_id
-  end
-
-  view :edit_in_form, perms: :update, tags: :unknown_ok do |args|
-    eform = form_for_multi
-    content = content_field eform, args.merge(nested: true)
-    content += raw("\n #{eform.hidden_field :type_id}") if card.new_card?
-    opts = { editor: 'content', help: true, class: 'card-editor' }
-    if card.cardname.junction?
-      opts[:class] += " RIGHT-#{card.cardname.tag_name.safe_key}"
-    end
-    formgroup fancy_title(args[:title]), content, opts
-  end
-
-  # form helpers
-
-  FIELD_HELPERS =
-    %w(
-      hidden_field color_field date_field datetime_field datetime_local_field
-      email_field month_field number_field password_field phone_field
-      range_field search_field telephone_field text_area text_field time_field
-      url_field week_field file_field
-    ).freeze
-
-  FIELD_HELPERS.each do |method_name|
-    define_method(method_name) do |name, options={}|
-      form.send(method_name, name, options)
-    end
-  end
-
-  def check_box method, options={}, checked_value='1', unchecked_value='0'
-    form.check_box method, options, checked_value, unchecked_value
-  end
-
-  def radio_button method, tag_value, options={}
-    form.radio_button method, tag_value, options
-  end
-
-  def submit_button args={}
-    args.reverse_merge!(
-      situation: 'primary',
-      data: {}
-    )
-    text = args.delete(:text) || 'Submit'
-    args[:data][:disable_with] ||= args.delete(:disable_with) || 'Submitting'
-    button_tag text, args
-  end
-
-  # redirect to *previous if no :href is given
-  def cancel_button args={}
-    args.reverse_merge! type: 'button'
-    if args[:href]
-      add_class args, 'slotter'
-    else
-      add_class args, 'redirecter'
-      args[:href] = Card.path_setting('/*previous')
-    end
-    text = args.delete(:text) || 'Cancel'
-    button_tag text, args
-  end
-end