card 1.21.0 → 1.91

data/tmpsets/set/mod016-standard/all/rich_html/wrapper.rb

@@ -1,191 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module RichHtml; module Wrapper; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/all/rich_html/wrapper.rb ~~
-format :html do
-  def slot_options args
-    @@slot_option_keys ||=
-      Card::Content::Chunk::Include.options
-                                   .reject { |k| k == :view }
-                                   .unshift :home_view
-    options_hash = {}
-
-    if @context_names.present?
-      options_hash["name_context"] = @context_names.map(&:key) * ","
-    end
-
-    options_hash[:subslot] = "true" if args[:subslot]
-
-    @@slot_option_keys.each_with_object(options_hash) do |opt, hash|
-      hash[opt] = args[opt] if args[opt].present?
-    end
-
-    JSON(options_hash)
-  end
-
-  # Does two main things:
-  # (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 args={}
-    @slot_view = @current_view
-    classes = wrap_classes args
-    data = wrap_data args
-
-    div = content_tag :div, output(yield).html_safe,
-                      id: card.cardname.url_key,
-                      class: classes,
-                      data: data,
-                      style: h(args[:style])
-    add_debug_comments div
-  end
-
-  def add_debug_comments content
-    return content if params[:debug] != "slot" ||
-                      tagged(@current_view, :no_wrap_comments)
-    name = h card.name
-    space = "  " * @depth
-    "<!--\n\n#{space}BEGIN SLOT: #{name}\n\n-->" \
-    "#{div}" \
-    "<!--\n\n#{space}END SLOT: #{name}\n\n-->"
-  end
-
-  def wrap_classes args
-    [
-      ("card-slot" unless args[:no_slot]),
-      "#{@current_view}-view",
-      (args[:slot_class] if args[:slot_class]),
-      ("STRUCTURE-#{args[:structure].to_name.key}" if args[:structure]),
-      card.safe_set_keys
-    ].compact.join " "
-  end
-
-  def wrap_data args
-    {
-      "card-id" => card.id,
-      "card-name" => h(card.name),
-      "slot"      => html_escape_except_quotes(slot_options(args))
-    }
-  end
-
-  def wrap_body args={}
-    css_classes = ["card-body"]
-    css_classes << args[:body_class]                      if args[:body_class]
-    css_classes += ["card-content", card.safe_set_keys] if args[:content]
-    content_tag :div, class: css_classes.compact * " " do
-      yield args
-    end
-  end
-
-  def panel args={}
-    wrap_with :div, class: "card-frame #{args[:panel_class]}" do
-      output(yield)
-    end
-  end
-
-  def frame args={}, &block
-    if args[:subframe]
-      args.delete(:panel_class)
-      subframe args, &block
-    else
-      show_subheader =
-        show_view?(:toolbar, args.merge(default_visibility: :hide)) &&
-        @current_view != :related && @current_view != :open
-
-      wrap args do
-        [
-          _optional_render(:menu, args),
-          panel(args) do
-            [
-              _optional_render(:header, args, :show),
-              _optional_render(:subheader, args,
-                               (show_subheader ? :show : :hide)),
-              _optional_render(:help,
-                               args.merge(help_class: "alert alert-info"),
-                               :hide),
-              wrap_body(args) { output(yield(args)) }
-            ]
-          end
-        ]
-      end
-    end
-  end
-
-  def subframe args={}
-    wrap args do
-      [
-        _optional_render(:menu, args.merge(optional_horizontal_menu: :hide)),
-        _optional_render(:subheader, args, :show),
-        _optional_render(:help, args.merge(help_class: "alert alert-info"),
-                         :hide),
-        panel(args) do
-          [
-            _optional_render(:header, args, :hide),
-            wrap_body(args) { output(yield args) }
-          ]
-        end
-      ]
-    end
-  end
-
-  def frame_and_form action, args={}, form_opts={}
-    form_opts.merge! args.delete(:form_opts) if args[:form_opts]
-    form_opts[:hidden] = args.delete(:hidden) if args[:hidden]
-    frame args do
-      card_form action, form_opts do
-        output(yield args)
-      end
-    end
-  end
-
-  # alert_types: 'success', 'info', 'warning', 'danger'
-  def alert alert_type, args={}
-    css_class = "alert alert-#{alert_type} "
-    css_class += "alert-dismissible " if args[:dismissible]
-    css_class += args[:alert_class] if args[:alert_class]
-    close_button =
-      if args[:dismissible]
-        <<-HTML
-          <button type="button" class="close" data-dismiss="alert"
-                  aria-label="Close">
-            <span aria-hidden="true">&times;</span>
-          </button>
-        HTML
-      else
-        ""
-      end
-    content_tag :div, class: css_class, role: "alert" do
-      close_button + output(yield args)
-    end
-  end
-
-  def wrap_main content
-    return content if Env.ajax? || params[:layout] == "none"
-    %(<div id="main">#{content}</div>)
-  end
-
-  def wrap_with tag, content_or_args={}, html_args={}
-    if block_given?
-      content_tag(tag, content_or_args) do
-        output(yield).html_safe
-      end
-    else
-      content_tag(tag, html_args) do
-        output(content_or_args).html_safe
-      end
-    end
-  end
-
-  def wrap_each_with tag, content_or_args={}, args={}
-    content = block_given? ? yield(args) : content_or_args
-    args    = block_given? ? content_or_args : args
-    content.compact.map do |item|
-      wrap_with tag, args do
-        item
-      end
-    end.join "\n"
-  end
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/all/rich_html/wrapper.rb ~~
-end;end;end;end;end;

data/tmpsets/set/mod016-standard/right/discussion.rb

@@ -1,10 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Right; module Discussion; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/discussion.rb ~~
-def show_comment_box_in_related?
-  true
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/discussion.rb ~~
-end;end;end;end;

data/tmpsets/set/mod016-standard/right/when_created.rb

@@ -1,14 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Right; module WhenCreated; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/when_created.rb ~~
-view :raw do |_args|
-  # .strftime('%A, %B %d, %Y %I:%M %p %Z')
-  card.left.new_card? ? "" : I18n.localize(card.left.created_at,
-                                           format: :card_dayofwk_min_tz)
-end
-
-view :core, :raw
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/when_created.rb ~~
-end;end;end;end;

data/tmpsets/set/mod016-standard/right/when_last_edited.rb

@@ -1,14 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Right; module WhenLastEdited; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/when_last_edited.rb ~~
-view :raw do |_args|
-  # .strftime('%A, %B %d, %Y %I:%M %p %Z')
-  card.left.new_card? ? "" : I18n.localize(card.left.updated_at,
-                                           format: :card_dayofwk_min_tz)
-end
-
-view :core, :raw
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/right/when_last_edited.rb ~~
-end;end;end;end;

data/tmpsets/set/mod016-standard/rstar/rules.rb

@@ -1,107 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Rstar; module Rules; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/rstar/rules.rb ~~
-event :save_recently_edited_settings, :integrate,
-      on: :save, when: proc { |c| c.is_rule? } do
-  if (recent = Card[:recent_settings])
-    recent.insert_item 0, cardname.right
-    recent.save
-  end
-end
-
-def rule_set_key
-  rule_set_name.key
-end
-
-def rule_set_name
-  if is_preference?
-    cardname.trunk_name.trunk_name
-  else
-    cardname.trunk_name
-  end
-end
-
-def rule_set
-  if is_preference?
-    self[0..-3]
-  else
-    trunk
-  end
-end
-
-def rule_setting_name
-  cardname.tag
-end
-
-def rule_user_setting_name
-  if is_preference?
-    "#{rule_user_name}+#{rule_setting_name}"
-  else
-    rule_setting_name
-  end
-end
-
-def rule_user_name
-  is_preference? ? cardname.trunk_name.tag : nil
-end
-
-def rule_user
-  is_preference? ? self[-2] : nil
-end
-
-# ~~~~~~~~~~ determine the set options to which the user can apply the rule.
-def set_options
-  first = if new_card?
-            0
-          else
-            set_prototype.set_names.index { |s| s.to_name.key == rule_set_key }
-          end
-  rule_cnt = 0
-  res = []
-  fallback_set = nil
-  set_prototype.set_names[first..-1].each do |set_name|
-    if Card.exists?("#{set_name}+#{rule_user_setting_name}")
-      rule_cnt += 1
-      res << if rule_cnt == 1
-               [set_name, :current]
-             else
-               fallback_set ||= set_name
-               [set_name, :overwritten]
-             end
-    else
-      res << (rule_cnt < 1 ? [set_name, :enabled] : [set_name, :disabled])
-    end
-  end
-
-  # fallback_set = if first > 0
-  #                 res[0..(first-1)].find do |set_name|
-  #                   Card.exists?("#{set_name}+#{rule_user_setting_name}")
-  #                 end
-  #               end
-  # last = res.index{|s| s.to_name.key == cardname.trunk_name.key} || -1
-  # # note, the -1 can happen with virtual cards because the self set doesn't
-  # show up in the set_names.  FIXME!!
-  # [res[first..last], fallback_set]
-  #
-  # The broadest set should always be the currently applied rule
-  # (for anything more general, they must explicitly choose to 'DELETE' the
-  # current one)
-  # the narrowest rule should be the one attached to the set being viewed.
-  # So, eg, if you're looking at the '*all plus' set, you shouldn't
-  # have the option to create rules based on arbitrary narrower sets, though
-  # narrower sets will always apply to whatever prototype we create
-
-  [res, fallback_set]
-end
-
-def set_prototype
-  if is_preference?
-    self[0..-3].prototype
-  else
-    trunk.prototype
-  end
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/rstar/rules.rb ~~
-end;end;end;end;

data/tmpsets/set/mod016-standard/rstar/rules_editor.rb

@@ -1,371 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Rstar; module RulesEditor; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/rstar/rules_editor.rb ~~
-format :html do
-  view :closed_rule, tags: :unknown_ok do
-    # these are helpful for handling non-rule rstar cards until we have real
-    # rule sets
-    return "not a rule" unless card.is_rule?
-
-    rule_card = find_current_rule_card
-    rule_content =
-      if rule_card
-        subformat(rule_card)._render_closed_content(
-          set_context: card.cardname.trunk_name
-        )
-      else
-        ""
-      end
-
-    cells = [
-      ["rule-setting",
-       link_to(
-         card.cardname.tag.sub(/^\*/, ""), path(view: :open_rule),
-         class: "edit-rule-link slotter", remote: true, rel: "nofollow"
-       )
-      ],
-      ["rule-content",
-       %(<div class="rule-content-container">
-           <span class="closed-content content">#{rule_content}</span>
-         </div> )],
-      ["rule-set", (rule_card ? rule_card.trunk.label : "")]
-    ]
-    extra_css_class =
-      rule_card && !rule_card.new_card? ? "known-rule" : "missing-rule"
-
-    row =
-      cells.map do |css_class, content|
-        %(<td class="rule-cell #{css_class} #{extra_css_class}">#{content}</td>)
-      end.join("\n")
-
-    %(<tr class="card-slot closed-rule"> #{row} </tr>)
-  end
-
-  view :open_rule, tags: :unknown_ok do |args|
-    return "not a rule" unless card.is_rule?
-    current_rule = args[:current_rule]
-    setting_name = args[:setting_name]
-
-    edit_mode =
-      !params[:success] && card.ok?((card.new_card? ? :create : :update))
-    # ~~~~~~ handle reloading due to type change
-    if params[:type_reload] && (card_args = params[:card])
-      if card_args[:name] && card_args[:name].to_name.key != current_rule.key
-        current_rule = Card.new card_args
-      else
-        current_rule = current_rule.refresh
-        current_rule.assign_attributes card_args
-        current_rule.include_set_modules
-      end
-      edit_mode = true
-    end
-
-    opts = {
-      rule_context: card,   # determines the set options and the success view
-      set_context:  card.rule_set_name
-    }
-    rule_view = edit_mode ? :edit_rule : :show_rule
-
-    <<-HTML
-      <tr class="card-slot open-rule #{rule_view.to_s.sub '_', '-'}">
-        <td class="rule-cell" colspan="3">
-          <div class="rule-setting">
-            #{view_link setting_name.sub(/^\*/, ''), :closed_rule,
-                        class: 'close-rule-link slotter'}
-            #{card_link setting_name,
-                        text: "all #{setting_name} rules",
-                        class: 'setting-link',
-                        target: 'wagn_setting'}
-          </div>
-
-          <div class="alert alert-info rule-instruction">
-            #{process_content "{{#{setting_name}+*right+*help|content}}"}
-          </div>
-
-          <div class="card-body">
-            #{subformat(current_rule)._render rule_view, opts}
-          </div>
-        </td>
-      </tr>
-    HTML
-  end
-
-  def default_open_rule_args args
-    current_rule_card = find_current_rule_card || begin
-      Card.new name: "#{Card[:all].name}+#{card.rule_user_setting_name}"
-    end
-    args.reverse_merge! current_rule: current_rule_card,
-                        setting_name: card.rule_setting_name
-  end
-
-  view :show_rule, tags: :unknown_ok do |args|
-    return "not a rule" unless card.is_rule?
-
-    if !card.new_card?
-      set = card.rule_set
-      args[:item] ||= :link
-      %(
-        <div class="rule-set">
-        <label>Applies to</label> #{card_link set.cardname, text: set.label}:
-        </div>
-        #{_render_core args}
-      )
-    else
-      "No Current Rule"
-    end
-  end
-
-  view :edit_rule, tags: :unknown_ok do |args|
-    return "not a rule" unless card.is_rule?
-    form_args = {
-      url: path(action: :update, no_id: true),
-      html: { class: "card-form card-rule-form" }
-    }
-    if args[:remote]
-      form_args[:remote] = true
-      form_args[:html][:class] += " slotter"
-    end
-
-    form_for card, form_args do |form|
-      @form = form
-      %(
-        #{hidden_success_formgroup args[:success]}
-        #{editor args}
-        #{edit_buttons args}
-      )
-    end
-  end
-
-  view :edit_single_rule do |args|
-    %(<div class="edit-single-rule panel-body">#{render_edit_rule args}</div>)
-  end
-
-  def default_edit_rule_args args
-    args[:remote] ||= true
-    args[:rule_context] ||= card
-    args[:set_context] ||= card.rule_set_name
-    args[:set_selected] = params[:type_reload] ? card.rule_set_name : false
-    args[:set_options], args[:fallback_set] = args[:rule_context].set_options
-
-    args[:success] ||= {}
-    args[:success].reverse_merge!(
-      card: args[:rule_context],
-      id:   args[:rule_context].cardname.url_key,
-      view: "open_rule",
-      item: "view_rule"
-    )
-    edit_rule_button_args args
-  end
-
-  def edit_rule_button_args args
-    args[:delete_button] ||= delete_button args
-    args[:cancel_button] ||=
-      begin
-        cancel_view = card.new_card? ? :closed_rule : :open_rule
-        cancel_button class: "rule-cancel-button",
-                      href: path(view: cancel_view, success: false)
-      end
-  end
-
-  def default_edit_single_rule_args args
-    args[:remote] ||= false
-    args[:success] ||= {
-      card: args[:parent] || card,
-      id: (args[:parent] && args[:parent].cardname.url_key) ||
-          card.cardname.url_key,
-      view: :open,
-      item: nil
-    }
-    default_edit_rule_args args
-    edit_single_rule_button_args args
-  end
-
-  def edit_single_rule_button_args args
-    args[:delete_button] = delete_button args, ".card-slot.related-view"
-    args[:cancel_button] = card_link(
-      args[:success][:id],
-      text: "Cancel",
-      class: "rule-cancel-button btn btn-default",
-      path_opts: { view: args[:success][:view] }
-    )
-  end
-
-  def delete_button args, slot_selector=nil
-    return if card.new_card?
-    b_args = {
-      remote: true, class: "rule-delete-button slotter", type: "button"
-    }
-    b_args["data-slot-selector"] = slot_selector if slot_selector
-    b_args[:href] = path action: :delete, success: args[:success]
-    if (fset = args[:fallback_set]) && (fcard = Card.fetch(fset))
-      b_args["data-confirm"] =
-        "Deleting will revert to #{card.rule_setting_name} rule for " \
-        "#{fcard.label}"
-    end
-    %(<span class="rule-delete-section">#{button_tag 'Delete', b_args}</span>)
-  end
-
-  # used keys for args:
-  # :success,  :set_selected, :set_options, :rule_context
-  def editor args
-    content = content_field(form, args.merge(skip_rev_id: true))
-    wrap_with(:div, class: "card-editor") do
-      [
-        (type_formgroup(args) if card.right.rule_type_editable),
-        formgroup("rule", content, editor: "content"),
-        set_selection(args)
-      ]
-    end
-  end
-
-  def type_formgroup args
-    content = type_field(
-      href: path(name: args[:success][:card].name,
-                 view: args[:success][:view],
-                 type_reload: true),
-      class: "type-field rule-type-field live-type-field",
-      "data-remote" => true
-    )
-    formgroup "type", content, editor: "type"
-  end
-
-  def hidden_success_formgroup args
-    %(
-      #{hidden_field_tag 'success[id]', args[:id] || args[:card].name}
-      #{hidden_field_tag 'success[view]', args[:view]}
-      #{hidden_field_tag 'success[item]', args[:item]}
-    )
-  end
-
-  def set_selection args
-    wrap_with(:div, class: "row") do
-      [
-        set_formgroup(args),
-        related_set_formgroup(args)
-      ]
-    end
-  end
-
-  def set_formgroup args
-    tag = args[:rule_context].rule_user_setting_name
-    narrower_rules = []
-    option_list "set" do
-      args[:set_options].map do |set_name, state|
-        set_radio_button set_name, tag, state, narrower_rules,
-                         checked: checked_set_button?(set_name, args)
-      end
-    end
-  end
-
-  def set_radio_button set_name, tag, state, narrower_rules, opts
-    button = radio_button :name, "#{set_name}+#{tag}",
-                          checked: opts[:checked],
-                          warning: narrower_rule_warning(narrower_rules)
-    label = Card.fetch(set_name).label
-    if state.in? [:current, :overwritten]
-      narrower_rules << label
-      narrower_rules.last[0] = narrower_rules.last[0].downcase
-    end
-    button + set_label(card, set_name, label, state)
-  end
-
-  def checked_set_button? set_name, args
-    (args[:set_selected] == set_name) ||
-      (current_set_key && args[:set_options].length == 1)
-  end
-
-  def current_set_key
-    card.new_card? ? Card[:all].cardname.key : card.rule_set_key
-  end
-
-  def related_set_formgroup args
-    related_sets = args[:set_context] &&
-                   Card.fetch(args[:set_context]).prototype.related_sets
-    return "" unless related_sets && related_sets.size > 0
-    tag = args[:rule_context].rule_user_setting_name
-    option_list "related set" do
-      related_sets.map do |set_name, label|
-        rule_name = "#{set_name}+#{tag}"
-        rule_card = Card.fetch rule_name, skip_modules: true
-        state = (rule_card && :exists)
-        radio_button(:name, rule_name) +
-          set_label(card, set_name, label, state)
-      end
-    end
-  end
-
-  def set_label card, set_name, label, state
-    info =
-      case state
-      when :current
-        "(current)"
-      when :overwritten, :exists
-        card_link "#{set_name}+#{card.rule_user_setting_name}",
-                  text: "(#{state})"
-      end
-    label = <<-HTML
-      <label class="set-label #{'current-set-label' if state == :current}">
-        #{card_link set_name, text: label, target: 'wagn_set'}
-        #{"<em> #{info} </em>" if info}
-      </label>
-    HTML
-    label.html_safe
-  end
-
-  def narrower_rule_warning narrower_rules
-    return unless narrower_rules.present?
-    plural = narrower_rules.size > 1 ? "s" : ""
-    "This rule will not have any effect on this card unless you delete " \
-    "the narrower rule#{plural} for #{narrower_rules.to_sentence}."
-  end
-
-  def option_list title
-    list =
-      wrap_each_with(:li, class: "radio") do
-        yield
-      end
-    formgroup title, "<ul>#{list}</ul>", editor: "set", class: "col-xs-6"
-  end
-
-  def edit_buttons  args
-    wrap_with(:div, class: "button-area") do
-      [
-        args[:delete_button],
-        button_tag("Submit", class: "rule-submit-button", situation: "primary"),
-        args[:cancel_button]
-      ]
-    end
-  end
-
-  # view :edit_rule2 do |args|
-  #
-  #   card_form :update do
-  #     [
-  #       _optional_render(:type_formgroup,    args),
-  #       _optional_render(:content_formgroup, args),
-  #       _optional_render(:set_formgroup,     args),
-  #       _optional_render(:button_formgroup,  args)
-  #     ]
-  #   end
-  # end
-
-  private
-
-  def find_current_rule_card
-    # self.card is a POTENTIAL rule; it quacks like a rule but may or may not
-    # exist.
-    # This generates a prototypical member of the POTENTIAL rule's set
-    # and returns that member's ACTUAL rule for the POTENTIAL rule's setting
-    if card.new_card?
-      if (setting = card.right)
-        card.set_prototype.rule_card setting.codename, user: card.rule_user
-      end
-    else
-      card
-    end
-  end
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/rstar/rules_editor.rb ~~
-end;end;end;end;