card 1.96.8 → 1.97.0

data/mod/standard/set/all/rich_html/modal.rb

@@ -1,35 +1,116 @@
 format :html do
+  MODAL_SIZE = { small: "sm", medium: nil, large: "lg", full: "full" }.freeze
+  MODAL_CLOSE_OPTS = { class: "_close-modal", "data-dismiss": "modal",
+                       "data-cy": "close-modal" }.freeze
+
+  wrapper :modal do |opts={}|
+    haml :modal_dialog, body: interior,
+                        classes: modal_dialog_classes(opts),
+                        title: normalize_modal_option(:title, opts),
+                        menu: normalize_modal_option(:menu, opts),
+                        footer: normalize_modal_option(:footer, opts)
+  end
+
+  def normalize_modal_option key, opts
+    val = opts[key]
+    return render("modal_#{key}") unless val
+    cast_model_option val
+  end
+
+  def cast_model_option val
+    case val
+    when Symbol
+      cast_model_option_symbol val
+    when Proc
+      val.call(self)
+    else
+      val
+    end
+  end
+
+  def cast_model_option_symbol val
+    respond_to?(val) ? send(val) : val
+  end
+
+  view :modal, wrap: :modal do
+    ""
+  end
+
+  def show_in_modal_link link_text, body
+    link_to_view :modal, link_text, "data-modal-body": body, "data-slotter-mode": "modal"
+  end
+
+  def modal_close_button link_text="Close", opts={}
+    classes = opts.delete(:class)
+    button_opts = opts.merge(MODAL_CLOSE_OPTS)
+    add_class button_opts, classes if classes
+    button_tag link_text, button_opts
+  end
+
+  def modal_submit_button opts={}
+    add_class opts, "submit-button _close-modal"
+    submit_button opts
+  end
+
+  view :modal_menu, tags: :unknown_ok, wrap: :modal_menu do
+    [close_modal_window, pop_out_modal_window]
+  end
+
+  wrapper :modal_menu, :div, class: "modal-menu ml-auto"
+
+  view :modal_title, tags: :unknown_ok do
+    ""
+  end
+
+  view :modal_footer, tags: :unknown_ok do
+    button_tag "Close",
+               class: "btn-xs _close-modal float-right",
+               "data-dismiss" => "modal"
+  end
+
   view :modal_link do
-    modal_link
+    modal_link _render_title, size: voo.size
   end
 
+  # @param size [:small, :medium, :large, :full] size of the modal dialog
   def modal_link text=nil, opts={}
-    text ||= render_title
-    opts.reverse_merge! path: {},
-                        "data-target": "#modal-main-slot",
-                        "data-toggle": "modal"
+    opts = modal_link_opts(opts)
     opts[:path][:layout] ||= :modal
     link_to text, opts
   end
 
-  def modal_slot modal_id=nil, dialog_class=nil
-    wrap_with :div, class: "modal fade _modal-slot",
-                    role: "dialog", id: "modal-#{modal_id || 'main-slot'}" do
-      wrap_with :div, class: css_classes("modal-dialog", dialog_class) do
-        wrap_with(:div, class: "modal-content") { "" }
-      end
-    end.html_safe
+  def modal_link_opts opts
+    add_class opts, "slotter"
+    opts.reverse_merge! path: {},
+                        "data-slotter-mode": "modal",
+                        "data-modal-class": modal_dialog_classes(opts),
+                        remote: true
+    opts
   end
 
-  view :modal_menu, tags: :unknown_ok do
-    wrap_with :div, class: "modal-menu w-100" do
-      [close_modal_window, pop_out_modal_window]
-    end
+  def modal_dialog_classes opts
+    classes = [classy("modal-dialog")]
+    return classes unless opts.present?
+
+    add_modal_size_class classes, opts.delete(:size)
+    classes << "modal-dialog-centered" if opts.delete(:vertically_centered)
+    classes.join " "
+  end
+
+  def add_modal_size_class classes, size
+    size = normalize_modal_size_class size
+    return if size == :medium || size.blank?
+
+    classes << "modal-#{MODAL_SIZE[size]}"
+  end
+
+  def normalize_modal_size_class size
+    size.in?(MODAL_SIZE.keys) ? size : cast_model_option(size)
   end
 
   def close_modal_window
     link_to icon_tag(:close), path: "",
-                              class: "close-modal float-right close",
+                              class: "_close-modal close",
                               "data-dismiss": "modal"
   end
 
@@ -39,12 +120,6 @@ format :html do
     # (eg we don't want layout, id, controller...)
     popout_params = params[:view] ? { view: params[:view] } : {}
     link_to icon_tag(:new_window), path: popout_params,
-                                   class: "pop-out-modal float-right close "
-  end
-
-  view :modal_footer, tags: :unknown_ok do
-    button_tag "Close",
-               class: "btn-xs close-modal float-right",
-               "data-dismiss" => "modal"
+                                   class: "pop-out-modal close"
   end
 end

data/mod/standard/set/all/rich_html/modal/modal_dialog.haml

@@ -0,0 +1,12 @@
+#modal-container.modal.fade._modal-slot{role: "dialog"}
+  -# .modal-dialog
+  %div{class: classes}
+    .modal-content
+      .modal-header.clearfix
+        = title
+        = menu
+      .modal-body
+        = body
+      - if footer.present?
+        .modal-footer
+          = footer

data/mod/standard/set/all/rich_html/overlay.rb

@@ -1,18 +1,27 @@
 format :html do
-  view :overlay do
-    overlay [_render_open_content, render_comment_box]
-  end
+  OVERLAY_CLOSE_OPTS = { class: "_close-overlay btn-sm",
+                         "data-dismiss": "overlay",
+                         type: "button" }.freeze
 
-  def overlay content=nil
-    class_up "card-slot", "_overlay d0-card-overlay bg-white", true
+  wrapper :overlay do |opts|
+    class_up "card-slot", "_overlay d0-card-overlay bg-white"
     @content_body = true
-    frame do
-      block_given? ? yield : content
+    voo.hide! :menu
+    overlay_frame true, overlay_header(opts[:title]), opts[:slot] do
+      interior
     end
   end
 
+  view :overlay_header, tags: :unknown_ok do
+    overlay_header
+  end
+
+  view :overlay_title do
+    _render_title
+  end
+
   view :overlay_menu do
-    wrap_with :div, class: "btn-group btn-group-sm" do
+    wrap_with :div, class: "btn-group btn-group-sm align-self-start ml-auto" do
       [slotify_overlay_link, close_overlay_link]
     end
   end
@@ -25,14 +34,49 @@ format :html do
     overlay_menu_link :close, path: "#", "data-dismiss": "overlay"
   end
 
+  def overlay_close_button link_text="Close", opts={}
+    classes = opts.delete(:class)
+    button_opts = opts.merge(OVERLAY_CLOSE_OPTS)
+    add_class button_opts, classes if classes
+    button_tag link_text, button_opts
+  end
+
+  def overlay_save_and_close_button
+    submit_button text: "Save and Close", class: "_close-overlay-on-success",
+                  "data-cy": "submit-overlay"
+  end
+
   def overlay_menu_link icon, args={}
-    add_class args, "border-light text-dark p-1"
+    add_class args, "border-light text-dark p-1 ml-1"
     button_link fa_icon(icon, class: "fa-lg"), args.merge(btn_type: "outline-secondary")
   end
 
-  view :overlay_header do
-    class_up "d0-card-header", "bg-white text-dark", true
-    class_up "d0-card-header-title", "d-flex justify-content-between", true
-    header_wrap [_render_title, _render_overlay_menu]
+  def overlay_header title=nil
+    title ||= _render_overlay_title
+    class_up "d0-card-header", "bg-white text-dark"
+    class_up "d0-card-header-title", "d-flex"
+    header_wrap [title, _render_overlay_menu]
+  end
+
+  def overlay_frame slot=true, header=render_overlay_header, slot_opts=nil
+    slot_opts ||= {}
+    overlay_framer slot, header, slot_opts do
+      wrap_body { yield }
+    end
+  end
+
+  def haml_overlay_frame slot=true, header=render_overlay_header
+    overlay_framer slot, header, {} do
+      haml_wrap_body { yield }
+    end
+  end
+
+  private
+
+  def overlay_framer slot, header, slot_opts
+    class_up "card-slot", "_overlay"
+    with_frame slot, header, slot_opts do
+      yield
+    end
   end
 end

data/mod/standard/set/all/rich_html/process_layout.rb

@@ -0,0 +1,91 @@
+format :html do
+  # TODO: use CodeFile cards for these
+  # builtin layouts allow for rescue / testing
+  HTML_LAYOUTS = Mod::Loader.load_layouts(:html).merge "none" => "{{_main}}"
+  HAML_LAYOUTS = Mod::Loader.load_layouts(:haml)
+
+  def show_with_page_layout view, args
+    main!
+    args = main_render_args view, args
+    if explicit_modal_wrapper?(view) && page_layout.to_sym != :modal
+      render_outside_of_layout view, args
+    else
+      render_with_layout view, page_layout, args
+    end
+  end
+
+  def main_render_args view, args
+    args[:view] = view if view
+    args[:main] = true
+    args[:main_view] = true
+    args
+  end
+
+  def page_layout
+    params[:layout] || layout_name_from_rule || :default
+  end
+
+  def render_with_layout view, layout, args={}
+    view_opts = Layout.main_nest_opts(layout, self)
+    view ||= view_opts.delete(:view) || default_nest_view
+    view_opts[:layout] = layout
+    render! view, view_opts.reverse_merge(args)
+  end
+
+  def render_outside_of_layout view, args
+    body = render_with_layout(nil, page_layout, {})
+    modal = render!(view, args)
+    if body.include?("</body>")
+      # a bit hacky
+      # the problem is that the body tag has to be in the layout
+      # so that you can add layout css classes like <body class="right-sidebar">
+      body.sub!("</body>", "#{modal}</body>")
+    else
+      body += modal
+    end
+    body
+  end
+
+  def show_layout?
+    !Env.ajax? || params[:layout]
+  end
+
+  def explicit_modal_wrapper? view
+    return unless view_setting(:wrap, view)
+
+    wrapper_names(view_setting(:wrap, view)).any? { |n| n == :modal || n == :bridge }
+  end
+
+  def wrapper_names wrappers
+    case wrappers
+    when Hash  then wrappers.keys
+    when Array then wrappers.map { |w| w.is_a?(Array) ? w.first : w }
+    else            [wrappers]
+    end
+  end
+
+  def process_haml_layout layout_name
+    haml HAML_LAYOUTS[layout_name]
+  end
+
+  def process_content_layout layout_name
+    content = layout_from_card_or_code layout_name
+    process_content content, chunk_list: :references
+  end
+
+  def layout_type layout_name
+    HAML_LAYOUTS[layout_name.to_s].present? ? :haml : :content
+  end
+
+  def layout_name_from_rule
+    card.rule_card(:layout)&.try :item_name
+  end
+
+  def layout_from_card_or_code name
+    layout_card_content(name) || HTML_LAYOUTS[name] || unknown_layout(name)
+  end
+
+  def built_in_layouts
+    HTML_LAYOUTS.merge(HAML_LAYOUTS).keys.sort.join ", "
+  end
+end

data/mod/standard/set/all/rich_html/show.rb

@@ -0,0 +1,37 @@
+format :html do
+  def show view, args
+    content = send show_method, view, args
+    show_full_page? ? wrap_with_html_page(content) : content
+  end
+
+  def show_method
+    "show_#{show_layout? ? :with : :without}_page_layout"
+  end
+
+  def show_without_page_layout view, args
+    @main = true if params[:is_main] || args[:main]
+    args.delete(:layout)
+    view ||= args[:home_view] || :open
+    render! view, args
+  end
+
+  def show_full_page?
+    !Env.ajax?
+  end
+
+  wrapper :html_page do
+    <<-HTML.strip_heredoc
+      <!DOCTYPE HTML>
+      <html>
+        <head>
+          #{head_content}
+        </head>
+        #{interior}
+      </html>
+    HTML
+  end
+
+  def head_content
+    nest card.rule_card(:head), view: :head_content
+  end
+end

data/mod/standard/set/all/rich_html/wrapper.rb

@@ -3,28 +3,38 @@ format :html do
   # (1) gives CSS classes for styling and
   # (2) adds card data for javascript - including the "card-slot" class,
   #     which in principle is not supposed to be in styles
-  def wrap slot=true, slot_attr={}, &block
-    method_wrap :wrap_with, slot, slot_attr, &block
+  def wrap slot=true, slot_attr={}, tag=:div, &block
+    method_wrap :wrap_with, tag, slot, slot_attr, &block
   end
 
-  def haml_wrap slot=true, slot_attr={}, &block
-    method_wrap :haml_tag, slot, slot_attr, &block
+  wrapper :slot do |opts|
+    method_wrap :wrap_with, :div, true, opts do
+      interior
+    end
+  end
+
+  def haml_wrap slot=true, slot_attr={}, tag=:div, &block
+    method_wrap :haml_tag, tag, slot, slot_attr, &block
   end
 
-  def method_wrap method, slot, slot_attr, &block
+  def method_wrap method, tag, slot, slot_attr, &block
     @slot_view = @current_view
     debug_slot do
-      send method, :div, slot_attributes(slot, slot_attr), &block
+      send method, tag, slot_attributes(slot, slot_attr), &block
     end
   end
 
   def slot_attributes slot, slot_attr
-    { id: card.name.url_key, class: wrap_classes(slot), data: wrap_data }.tap do |hash|
+    { id: slot_id, class: wrap_classes(slot), data: wrap_data }.tap do |hash|
       add_class hash, slot_attr.delete(:class)
       hash.deep_merge! slot_attr
     end
   end
 
+  def slot_id
+    "#{card.name.safe_key}-#{@current_view}-view"
+  end
+
   def wrap_data slot=true
     with_slot_data slot do
       { "card-id": card.id, "card-name": h(card.name) }
@@ -51,6 +61,7 @@ format :html do
 
   def name_context_slot_option opts
     return unless initial_context_names.present?
+
     opts[:name_context] = initial_context_names.map(&:key) * ","
   end
 
@@ -76,15 +87,24 @@ format :html do
   end
 
   def wrap_body
+    wrap_with(:div, class: body_css_classes) { yield }
+  end
+
+  def haml_wrap_body
+    wrap_body do
+      capture_haml { yield }
+    end
+  end
+
+  def body_css_classes
     css_classes = ["d0-card-body"]
     css_classes += ["d0-card-content", card.safe_set_keys] if @content_body
-    wrap_with :div, class: classy(*css_classes) do
-      yield
-    end
+    classy(*css_classes)
   end
 
   def wrap_main
     return yield if Env.ajax? || params[:layout] == "none"
+
     wrap_with :div, yield, id: "main"
   end
 
@@ -101,4 +121,21 @@ format :html do
       wrap_with(tag, args) { item }
     end.join "\n"
   end
+
+  private
+
+  def html_escape_except_quotes string
+    # to be used inside single quotes (makes for readable json attributes)
+    string.to_s.gsub(/&/,  "&")
+          .gsub(/\'/, "'")
+          .gsub(/>/,  ">")
+          .gsub(/</,  "&lt;")
+  end
+
+  wrapper :div, :div
+  wrapper :em, :em
+
+  wrapper :none do
+    interior
+  end
 end