card 1.16.15 → 1.17.0

data/mod/04_settings/set/right/structure.rb

@@ -1,6 +1,6 @@
 
 format :rss do
-  def raw_feed_items args
+  def raw_feed_items _args
     [card]
   end
 end
@@ -8,3 +8,49 @@ end
 format :html do
   include AddHelp::HtmlFormat
 end
+
+event :update_structurees_references,
+      before: :subsequent,
+      when: proc { |c| c.db_content_changed? || c.action == :delete } do
+  return unless (statement = structuree_statement)
+  Auth.as_bot do
+    Card::Query.run(statement).each(&:update_references)
+  end
+end
+
+event :update_structurees_type, after: :store, changed: :type_id,
+                                when: proc { |c| c.assigns_type? } do
+  update_structurees type_id: type_id
+end
+
+def structuree_names
+  if (wql = structuree_statement)
+    Auth.as_bot do
+      Card::Query.run(wql.merge return: :name)
+    end
+  else
+    []
+  end
+end
+
+def update_structurees args
+  # note that this is not smart about overriding templating rules
+  # for example, if someone were to change the type of a
+  # +*right+*structure rule that was overridden
+  # by a +*type plus right+*structure rule, the override would not be respected.
+
+  statement = structuree_statement
+  return unless statement
+  Auth.as_bot do
+    statement[:return] = :id
+    Card::Query.run(statement).each_slice(100) do |id_batch|
+      Card.where(id: id_batch).update_all args
+    end
+  end
+end
+
+def structuree_statement
+  set_card = trunk
+  return unless set_card.type_id == SetID
+  set_card.get_query
+end

data/mod/04_settings/set/self/default_html_view.rb

@@ -0,0 +1,2 @@
+extend Card::Setting
+setting_opts group: :other, position: 4, rule_type_editable: false

data/mod/04_settings/set/self/follow_fields.rb

@@ -0,0 +1,2 @@
+extend Card::Setting
+setting_opts group: :other, position: 5, rule_type_editable: false

data/mod/04_settings/set/self/recent_settings.rb

@@ -1,3 +1,3 @@
 def followable?
   false
-end
+end

data/mod/05_standard/set/all/links.rb

@@ -1,13 +1,12 @@
 
 
 format do
-
   # link is called by web_link, card_link, and view_link
   # (and is overridden in other formats)
-  def link_to text, href, opts={}
+  def link_to text, href, _opts={}
     href = interpret_href href
 
-    if text and href != text
+    if text && href != text
       "#{text}[#{href}]"
     else
       href
@@ -15,15 +14,14 @@ format do
   end
 
   # link to url, view, card or related card
-  #
   def smart_link link_text, target, html_args={}
     if (view = target.delete(:view))
       view_link link_text, view, html_args.merge(path_opts: target)
     elsif (page = target.delete(:card))
       card_link page, html_args.merge(path_opts: target, text: link_text)
     elsif target[:related]
-      if target[:related].kind_of? String
-        target[:related] = {name: "+#{target[:related]}"}
+      if target[:related].is_a? String
+        target[:related] = { name: "+#{target[:related]}" }
       end
       view_link link_text, :related, html_args.merge(path_opts: target)
     elsif target[:web]
@@ -32,16 +30,16 @@ format do
     end
   end
 
-
   # link to a specific url or path
   def web_link href, opts={}
     text = opts.delete(:text) || href
-    new_class = case href
-      when /^https?:/                      ; 'external-link'
-      when /^mailto:/                      ; 'email-link'
-      when /^([a-zA-Z][\-+\.a-zA-Z\d]*):/  ; $1 + '-link'
+    new_class =
+      case href
+      when /^https?\:/                     then 'external-link'
+      when /^mailto\:/                     then 'email-link'
+      when /^([a-zA-Z][\-+\.a-zA-Z\d]*):/  then $1 + '-link'
       when /^\//
-        href = internal_url href[1..-1]    ; 'internal-link'
+        (href = internal_url href[1..-1]) ;     'internal-link'
       else
         return card_link href, opts
       end
@@ -52,17 +50,19 @@ format do
 
   # link to a specific card
   def card_link name_or_card, opts={}
-    name = case name_or_card
-           when Symbol then Card.fetch( name_or_card, skip_modules: true ).cardname
-           when Card   then name_or_card.cardname
-           else             name_or_card
-           end
+    name =
+      case name_or_card
+      when Symbol then Card.fetch(name_or_card, skip_modules: true).cardname
+      when Card   then name_or_card.cardname
+      else             name_or_card
+      end
     text = (opts.delete(:text) || name).to_name.to_show @context_names
 
-    path_opts = opts.delete( :path_opts ) || {}
-    path_opts[:name ] = name
-    path_opts[:known] = opts[:known].nil? ? Card.known?(name) : opts.delete(:known)
-    add_class opts, ( path_opts[:known] ? 'known-card' : 'wanted-card' )
+    path_opts = opts.delete(:path_opts) || {}
+    path_opts[:name] = name
+    path_opts[:known] =
+      opts[:known].nil? ? Card.known?(name) : opts.delete(:known)
+    add_class opts, (path_opts[:known] ? 'known-card' : 'wanted-card')
     link_to text, path_opts, opts
   end
 
@@ -78,11 +78,12 @@ format do
   end
 
   def related_link name_or_card, opts={}
-    name = case name_or_card
-           when Symbol then Card.fetch( name_or_card, skip_modules: true ).cardname
-           when Card   then name_or_card.cardname
-           else             name_or_card
-           end
+    name =
+      case name_or_card
+      when Symbol then Card.fetch(name_or_card, skip_modules: true).cardname
+      when Card   then name_or_card.cardname
+      else             name_or_card
+      end
    opts[:path_opts] ||= {view: :related}
    opts[:path_opts][:related] = {name: "+#{name}"}
    opts[:path_opts][:related].merge! opts[:related_opts] if opts[:related_opts]

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

@@ -231,7 +231,7 @@ format :html do
       # with_inclusion_mode :edit do
       nested_fields(args).map do |chunk|
         nest Card.fetch("#{chunk.referee_name}+*self"),
-             view: :titled, rule_view: view,
+             view: :titled, title: chunk.referee_name, rule_view: view,
              optional_set_label: :hide,
              optional_rule_navbar: :show
       end

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

@@ -1,7 +1,7 @@
 
 format :html do
   def toolbar_pinned?
-    Card[:toolbar_pinned].content == 'true'
+    (tp = Card[:toolbar_pinned]) && tp.content == 'true'
   end
 
   view :toolbar do |args|

data/mod/05_standard/set/rstar/rules.rb

@@ -1,319 +1,11 @@
-event :save_recently_edited_settings, before: :extend, on: :save, when: proc{|c| c.is_rule? } do
+event :save_recently_edited_settings,
+      before: :extend, on: :save, when: proc { |c| c.is_rule? } do
   if (recent = Card[:recent_settings])
     recent.insert_item 0, cardname.right
     recent.save
   end
 end
 
-format :html do
-
-  view :closed_rule, tags: :unknown_ok do |args|
-    return 'not a rule' if !card.is_rule? #these are helpful for handling non-rule rstar cards until we have real rule sets
-
-    rule_card = find_current_rule_card
-
-    rule_content = !rule_card ? '' : begin
-      subformat(rule_card)._render_closed_content set_context: card.cardname.trunk_name
-    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'
-
-    %{<tr class="card-slot closed-rule">} +
-    cells.map do |css_class, content|
-      %{<td class="rule-cell #{css_class} #{extra_css_class}">#{content}</td>}
-    end.join("\n") +
-    '</tr>'
-  end
-
-
-  view :open_rule, tags: :unknown_ok do |args|
-    return 'not a rule' if !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
-
-    %{
-      <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>
-    }
-  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' if !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' if !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 :related_edit_rule, view: :edit_rule
-
-  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'
-    })
-
-    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_related_edit_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
-    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
-    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
-  end
-
-  # used keys for args:
-  # :success,  :set_selected, :set_options, :rule_context
-  def editor args
-    wrap_with( :div, class: 'card-editor' ) do
-      [
-        (type_formgroup( args ) if card.right.rule_type_editable),
-        formgroup( 'rule', content_field( form, args.merge(skip_rev_id: true) ), editor: 'content' ),
-        set_selection( args )
-      ]
-    end
-  end
-
-
-  def type_formgroup args
-    formgroup 'type', 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
-    ), 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
-    current_set_key = card.new_card? ? Card[:all].cardname.key : card.rule_set_key   # (should have a constant for this?)
-    tag = args[:rule_context].rule_user_setting_name
-    narrower_rules = []
-    option_list =
-      wrap_each_with :li, class: 'radio' do
-        args[:set_options].map do |set_name, state|
-
-          checked    = ( args[:set_selected] == set_name or current_set_key && args[:set_options].length==1 )
-          is_current = (state == :current)
-          warning = if 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
-          if is_current || state == :overwritten
-             narrower_rules << Card.fetch(set_name).label
-             narrower_rules.last[0] = narrower_rules.last[0].downcase
-          end
-          rule_name  = "#{set_name}+#{tag}"
-          radio_button( :name, rule_name, checked: checked, warning: warning ) + %{
-              <label class="set-label" #{'current-set-label' if is_current }>
-                #{ card_link set_name, text: Card.fetch(set_name).label, target: 'wagn_set' }
-                #{'<em>(current)</em>' if is_current }
-                #{"<em> #{card_link "#{set_name}+#{card.rule_user_setting_name}", text: "(overwritten)"}</em>" if state == :overwritten }
-              </label>
-             }.html_safe
-         end
-
-       end
-    formgroup 'set', "<ul>#{ option_list }</ul>", editor: 'set', class: 'col-xs-6'
-  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 =
-      wrap_each_with :li, class: 'radio' do
-        related_sets.map do |set_name, label|
-          rule_name  = "#{set_name}+#{tag}"
-          rule_card  = Card.fetch rule_name, skip_modules: true
-          radio_button( :name, rule_name) + %{
-              <label class="set-label">
-                #{ card_link set_name, text: label, target: 'wagn_set' }
-                #{"<em> #{card_link "#{set_name}+#{card.rule_user_setting_name}", text: "(exists)"}</em>" if rule_card}
-              </label>
-             }.html_safe
-        end
-      end
-    formgroup 'related set', "<ul>#{ option_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
-
-=begin
-  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
-=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
-
-
 def rule_set_key
   rule_set_name.key
 end
@@ -342,7 +34,7 @@ def rule_user_setting_name
   if is_user_rule?
     "#{rule_user_name}+#{rule_setting_name}"
   else
-   rule_setting_name
+    rule_setting_name
   end
 end
 
@@ -354,11 +46,13 @@ def rule_user
   is_user_rule? ? self[-2] : nil
 end
 
-
-#~~~~~~~~~~ determine the set options to which the user can apply the rule.
+# ~~~~~~~~~~ determine the set options to which the user can apply the rule.
 def set_options
-
-  first =  new_card? ? 0 : set_prototype.set_names.index{|s| s.to_name.key == rule_set_key}
+  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
@@ -366,13 +60,13 @@ def set_options
     if Card.exists?("#{set_name}+#{rule_user_setting_name}")
       rule_cnt += 1
       res << if rule_cnt == 1
-               [set_name,:current]
+               [set_name, :current]
              else
                fallback_set ||= set_name
-               [set_name,:overwritten]
+               [set_name, :overwritten]
              end
     else
-      res << (rule_cnt < 1 ? [set_name,:enabled] : [set_name,:disabled])
+      res << (rule_cnt < 1 ? [set_name, :enabled] : [set_name, :disabled])
     end
   end
 
@@ -382,13 +76,17 @@ def set_options
   #                 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!!
+  # # 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
+  # (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
 
   return res, fallback_set
 end
@@ -400,6 +98,3 @@ def set_prototype
     trunk.prototype
   end
 end
-
-
-