card 1.16.15 → 1.17.0

data/tmpsets/set/mod007-05_standard/right/status.rb

@@ -4,11 +4,11 @@ class Card; module Set; module Right; module Status; extend Card::Set
 include All::Permissions::Accounts
 
 def ok_to_update
-  if is_own_account? && !Auth.always_ok?
+  if own_account? && !Auth.always_ok?
     deny_because you_cant('change the status of your own account')
   else
     super
-  end 
+  end
 end
 
 

data/tmpsets/set/mod007-05_standard/right/token.rb

@@ -3,8 +3,55 @@ class Card; module Set; module Right; module Token; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_standard/set/right/token.rb ~~~~~~~~~~~
 include All::Permissions::Accounts
 
-view :raw do |args|
-  "Private data"
+DURATIONS = 'second|minute|hour|day|week|month|year'
+
+card_accessor :expiration
+
+view :raw do
+  'Private data'
+end
+
+def validate! token
+  error =
+    case
+    when !real?           then [:token_not_found, 'no token found']
+    when expired?         then [:token_expired, 'expired token']
+    when content != token then [:incorrect_token, 'token mismatch']
+    end
+  errors.add *error if error
+end
+
+def expired?
+  !permanent? && updated_at <= term.ago
+end
+
+def permanent?
+  term == 'permanent'
+end
+
+def used!
+  Auth.as_bot { delete! } unless permanent?
+end
+
+def term
+  @term ||=
+    if expiration.present?
+      term_from_string expiration
+    else
+      Card.config.token_expiry
+    end
+end
+
+def term_from_string string
+  string.strip!
+  return 'permanent' if string == 'none'
+  re_match = /^(\d+)[\.\s]*(#{DURATIONS})s?$/.match(string)
+  number, unit = re_match.captures if re_match
+  if unit
+    number.to_i.send unit
+  else
+    raise Card::Oops, "illegal expiration value (eg '2 days')"
+  end
 end
 
 

data/tmpsets/set/mod007-05_standard/rstar/rules.rb

@@ -1,322 +1,14 @@
 # -*- encoding : utf-8 -*-
 class Card; module Set; module Rstar; module Rules; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/05_standard/set/rstar/rules.rb ~~~~~~~~~~~
-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_path = path view: ( card.new_card? ? :closed_rule : :open_rule ), success: false
-        button_tag( 'Cancel', class: 'rule-cancel-button slotter', type: 'button',
-                          href: cancel_path )
-      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
@@ -345,7 +37,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
 
@@ -357,11 +49,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
@@ -369,13 +63,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
 
@@ -385,13 +79,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
@@ -405,8 +103,5 @@ def set_prototype
 end
 
 
-
-
-
 # ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/05_standard/set/rstar/rules.rb ~~~~~~~~~~~
 end;end;end;end;