card 1.19.4 → 1.19.5

data/mod/email/spec/set/all/notify_spec.rb

@@ -123,8 +123,8 @@ describe Card::Set::All::Notify do
       context "and missing permissions" do
         context "for subcard" do
           before do
-            Card.create_or_update! "#{name}+s1+*self+*read",
-                                   type: "Pointer", content: "[[Administrator]]"
+            create_or_update! "#{name}+s1+*self+*read",
+                              type: "Pointer", content: "[[Administrator]]"
           end
           it "excludes subcard content" do
             is_expected.not_to include sub1_content
@@ -142,10 +142,10 @@ describe Card::Set::All::Notify do
             ).text_part.body.raw_source
           end
           before do
-            Card.create_or_update! "#{name}+*self+*read",
-                                   type: "Pointer", content: "[[Administrator]]"
-            Card.create_or_update! "#{name}+s1+*self+*read",
-                                   type: "Pointer", content: "[[Anyone]]"
+            create_or_update! "#{name}+*self+*read",
+                              type: "Pointer", content: "[[Administrator]]"
+            create_or_update! "#{name}+s1+*self+*read",
+                              type: "Pointer", content: "[[Anyone]]"
           end
           it "includes subcard content" do
             is_expected.to include sub1_content
@@ -157,18 +157,18 @@ describe Card::Set::All::Notify do
         end
         context "for all parts" do
           before do
-            Card.create_or_update! "#{name}+s1+*self+*read",
-                                   type: "Pointer", content: "[[Administrator]]"
-            Card.create_or_update! "#{name}+s2+*self+*read",
-                                   type: "Pointer", content: "[[Administrator]]"
-            Card.create_or_update! "#{name}+*self+*read",
-                                   type: "Pointer", content: "[[Administrator]]"
+            create_or_update! "#{name}+s1+*self+*read",
+                              type: "Pointer", content: "[[Administrator]]"
+            create_or_update! "#{name}+s2+*self+*read",
+                              type: "Pointer", content: "[[Administrator]]"
+            create_or_update! "#{name}+*self+*read",
+                              type: "Pointer", content: "[[Administrator]]"
           end
           it { is_expected.not_to include content }
           it { is_expected.not_to include sub1_content }
           it { is_expected.not_to include sub2_content }
           it "will not be send" do
-            expect(Card["Joe User"].account.changes_visible? @card.acts.last)
+            expect(Card["Joe User"].account.changes_visible?(@card.acts.last))
               .to be_falsey
           end
         end
@@ -204,6 +204,9 @@ describe Card::Set::All::Notify do
         followed_set:  "#{@card.name}+*self",
         follow_option: "*always"
       ).text_part.body.raw_source
+      unfollow_link =
+        "/update/Joe_User+*follow?card%5Bsubcards%5D%5Banother+"\
+        "card+with+subcards%2B%2Aself%2BJoe+User%2B%2Afollow%5D=%2Anever"
       expect(result)
         .to eq(%("another card with subcards" was just created by Joe User.
 
@@ -230,7 +233,7 @@ See the card: /another_card_with_subcards
 
 You received this email because you're following "another card with subcards".
 
-Use this link to unfollow /update/Joe_User+*follow?card%5Bsubcards%5D%5Banother+card+with+subcards%2B%2Aself%2BJoe+User%2B%2Afollow%5D=%2Anever
+Use this link to unfollow #{unfollow_link}
 ))
     end
   end

data/mod/history/set/all/history.rb

@@ -233,7 +233,7 @@ format :html do
   end
 
   view :act_header do |_args|
-    %(<h5 class="act-header">#{card_link card}</h5>)
+    %(<h5 class="act-header">#{link_to_card card}</h5>)
   end
 
   view :act_metadata do |args|
@@ -244,7 +244,7 @@ format :html do
             = '#' + act_seq.to_s
         .title
           .actor
-            = link_to act.actor.name, card_url(act.actor.cardname.url_key)
+            = link_to_card act.actor
           .time.timeago
             = time_ago_in_words(act.acted_at)
             ago
@@ -306,17 +306,17 @@ format :html do
   end
 
   def name_diff action, hide_diff
+    working_name = name_changes action, hide_diff
     if action.card == card
-      name_changes(action, hide_diff)
+      working_name
     else
-      link_path = path(
-        view: :related,
-        related: { view: "history", name: action.card.name }
+      link_to_view(
+        :related, working_name,
+        path: { related: { view: "history", name: action.card.name } },
+        remote: true,
+        class: "slotter label label-default",
+        "data-slot-selector" => ".card-slot.history-view"
       )
-      link_to name_changes(action, hide_diff), link_path,
-              class: "slotter label label-default",
-              "data-slot-selector" => ".card-slot.history-view",
-              remote: true
     end
   end
 
@@ -370,45 +370,42 @@ format :html do
   end
 
   def fold_or_unfold_link args
-    path_opts = {
-      act_id:      args[:act].id,
-      act_seq:     args[:act_seq],
-      hide_diff:   args[:hide_diff],
-      act_context: args[:act_context],
-      action_view: (args[:action_view] == :expanded ? :summary : :expanded),
-      look_in_trash: true
-    }
+    act_id = args[:act].id
+    action_view = args[:action_view] == :expanded ? :summary : :expanded
     arrow_dir = args[:action_view] == :expanded ? "arrow-down" : "arrow-right"
-    view_link "", :act, path_opts: path_opts,
-                        class: "slotter revision-#{args[:act_id]} #{arrow_dir}"
+
+    link_to_view :act, "", class: "slotter revision-#{act_id} #{arrow_dir}",
+                           path: { act_id:      act_id,
+                                   act_seq:     args[:act_seq],
+                                   hide_diff:   args[:hide_diff],
+                                   act_context: args[:act_context],
+                                   action_view: action_view,
+                                   look_in_trash: true }
   end
 
   def rollback_link actions
-    not_current =
+    # @fixme -- doesn't this need to specify which action it wants?
+    prior =  # @fixme - should be a Card::Action method
       actions.select { |action| action.card.last_action_id != action.id }
-    return unless card.ok?(:update) && not_current.present?
-    link_path = path action: :update, view: :open, action_ids: not_current,
-                     look_in_trash: true
+    return unless card.ok?(:update) && prior.present?
     link = link_to(
-      "Save as current", link_path,
-      class: "slotter", "data-slot-selector" => ".card-slot.history-view",
-      remote: true, method: :post, rel: "nofollow"
+      "Save as current", class: "slotter",
+                         "data-slot-selector" => ".card-slot.history-view",
+                         remote: true, method: :post, rel: "nofollow",
+                         path: { action: :update, action_ids: prior,
+                                 view: :open, look_in_trash: true }
     )
     %(<div class="act-link">#{link}</div>)
   end
 
   def show_or_hide_changes_link args
-    toggle = args[:hide_diff] ? "Show" : "Hide"
-    path_opts = {
-      act_id: args[:act].id,
-      act_seq: args[:act_seq],
-      hide_diff: !args[:hide_diff],
-      action_view: :expanded,
-      act_context: args[:act_context],
-      look_in_trash: true
-    }
-    link = view_link("#{toggle} changes", :act,
-                     path_opts: path_opts, class: "slotter", remote: true)
+    link = link_to_view(
+      :act, "#{args[:hide_diff] ? 'Show' : 'Hide'} changes",
+      class: "slotter",
+      path: { act_id:      args[:act].id,      act_seq: args[:act_seq],
+              hide_diff:  !args[:hide_diff],   action_view: :expanded,
+              act_context: args[:act_context], look_in_trash: true }
+    )
     %(<div class="act-link">#{link}</div>)
   end
 end

data/mod/machines/spec/set/abstract/machine_spec.rb

@@ -1,3 +1,5 @@
+# -*- encoding : utf-8 -*-
+
 describe Card::Set::Abstract::Machine do
   describe "#make_machine_output_coded" do
     it "creates coded file" do

data/mod/settings/set/abstract/permission.rb

@@ -45,14 +45,11 @@ format :html do
 
   def groups item_names
     group_options.map do |option|
-      checked = !!item_names.delete(option.name)
-      %(
-        <div class="group-option">
-          #{check_box_tag("#{option.key}-perm-checkbox", option.name, checked,
-                          class: 'perm-checkbox-button')}
-          <label>#{card_link option.name, target: 'wagn_role'}</label>
-        </div>
-      )
+      checked = !item_names.delete(option.name).nil?
+      option_link = link_to_card option.name, nil, target: "wagn_role"
+      box = check_box_tag "#{option.key}-perm-checkbox",
+                          option.name, checked, class: "perm-checkbox-button"
+      %(<div class="group-option">#{box}<label>#{option_link}</label></div>)
     end * "\n"
   end
 
@@ -103,7 +100,7 @@ format :html do
     task = card.tag.codename
     ancestor = Card[set_context.trunk_name.trunk_name]
     links = ancestor.who_can(task.to_sym).map do |card_id|
-      card_link Card[card_id].name, target: args[:target]
+      link_to_card card_id, nil, target: args[:target]
     end * ", "
     "Inherit ( #{links} )"
   rescue

data/mod/settings/set/type/setting.rb

@@ -58,17 +58,18 @@ format do
           - card.set_classes_with_rules.each do |klass, rules|
             %tr.klass-row
               %td{class: ['setting-klass', "anchorless-#{klass.anchorless?}"]}
-                = klass.anchorless? ? card_link(klass.pattern) : klass.pattern
+                - kpat = klass.pattern
+                = klass.anchorless? ? link_to_card(kpat) : kpat
               %td.rule-content-container
                 %span.closed-content.content
                   - if klass.anchorless?
                     = subformat(rules[0])._render_closed_content
             - if !klass.anchorless?
               - duplicate_check(rules) do |rule, duplicate, changeover|
+                - setname = rule.cardname.trunk_name
                 %tr{class: ('rule-changeover' if changeover)}
                   %td.rule-anchor
-                    = card_link rule.cardname.trunk_name,
-                                text: rule.cardname.trunk_name.trunk_name
+                    = link_to_card setname, setname.trunk_name
                   - if duplicate
                     %td
                   - else

data/mod/solid_cache/set/abstract/solid_cache.rb

@@ -10,31 +10,36 @@
 
 card_accessor :solid_cache, type: :html
 
-format :html do
-  def default_core_args args
-    args[:solid_cache] = true unless args.key?(:solid_cache)
+def self.included host_class
+  host_class.format(host_class.try(:cached_format) || :base) do
+    view :core do |args|
+      return super(args) unless args[:solid_cache]
+      card.update_solid_cache if card.solid_cache_card.new?
+      subformat(card.solid_cache_card)._render_core args
+    end
   end
+end
 
-  view :core do |args|
-    return super(args) unless args[:solid_cache]
-
-    subformat(card.solid_cache_card)._render_core args
+format do
+  def default_core_args args
+    args[:solid_cache] = true unless args.key?(:solid_cache)
   end
 end
 
 module ClassMethods
-  # If a card of the set given by 'set_of_changed_card' is updated
+  # If a card of the set given by 'set_of_changed_card' is changed
   # the given block is executed. It is supposed to return an array of
-  # cards whose solid caches are expired because of the update.
+  # cards whose solid caches are expired because of the change.
   # @param set_of_changed_card [set constant] a set of cards that triggers
   #   a cache update
   # @param args [Hash]
-  # @option args [Symbol, Array of symbols] :on the action(s)
+  # @option args [Symbol, Array<Symbol>] :on the action(s)
   #   (:create, :update, or :delete) on which the cache update
   #   should be triggered. Default is all actions.
   # @option args [Stage] :in_stage the stage when the update is executed.
   #   Default is :integrate
-  # @yield return an array of cards with solid cache that need to be updated
+  # @yield return a card or an array of cards with solid cache that need to be
+  #   updated
   def cache_update_trigger set_of_changed_card, args={}, &block
     define_event_to_update_expired_cached_cards(
       set_of_changed_card, args, :update_solid_cache, &block
@@ -56,37 +61,53 @@ module ClassMethods
     stage = args[:in_stage] || :integrate
     Card::Set.register_set set_of_changed_card
     set_of_changed_card.event name, stage, args do
-      Array(yield(self)).compact.each do |expired_cache_card|
+      Array.wrap(yield(self)).compact.each do |expired_cache_card|
         next unless expired_cache_card.solid_cache?
-        expired_cache_card.send method_name
+        expired_cache_card.send method_name, self
       end
     end
   end
 
   def event_name set, args
-    changed_card_set = set.to_s.tr(":", "_").underscore
-    solid_cache_set = to_s.tr(":", "_").underscore
+    changed_card_set = set.shortname.tr(":", "_").underscore
+    solid_cache_set = shortname.tr(":", "_").underscore + "__solid_cache"
     actions = Array.wrap(args[:on]).join("_")
-    "update_#{solid_cache_set}_solid_cache_changed_by_" \
-    "#{changed_card_set}_on_#{actions}".to_sym
+    ["update", solid_cache_set,
+     "changed_by", changed_card_set,
+     "on", actions].join("___").to_sym
   end
 end
 
-def expire_solid_cache
+def expire_solid_cache _changed_card=nil
   return unless solid_cache?
   Auth.as_bot do
     solid_cache_card.delete!
   end
 end
 
-def update_solid_cache
+def update_solid_cache changed_card=nil
   return unless solid_cache?
-  new_content = format(:html)._render_core(solid_cache: false)
+  new_content =
+    if solid_cache_card.new?
+      generate_content_for_cache changed_card
+    else
+      updated_content_for_cache changed_card
+    end
   return unless new_content
   write_to_solid_cache new_content
   new_content
 end
 
+def generate_content_for_cache changed_card=nil
+  format_type = try(:cached_format) || :base
+  format(format_type)._render_core(solid_cache: false,
+                                   changed_card: changed_card)
+end
+
+def updated_content_for_cache _changed_card=nil
+  generate_content_for_cache
+end
+
 def write_to_solid_cache new_content
   Auth.as_bot do
     if solid_cache_card.new_card?

data/mod/solid_cache/spec/set/abstract/solid_cache_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 
 describe Card::Set::Abstract::SolidCache do
   context "render core view of a card" do
@@ -5,7 +6,8 @@ describe Card::Set::Abstract::SolidCache do
       @card = Card["A"]
     end
 
-    let(:core_view) { 'Alpha <a class="known-card" href="/Z">Z</a>' }
+    # let(:core_view) { 'Alpha <a class="known-card" href="/Z">Z</a>' }
+    let(:core_view) { "Alpha Z[/Z]" }
     context "with solid cache" do
       it "saves core view in solid cache card" do
         @card.format_with_set(Card::Set::Abstract::SolidCache, &:render_core)

data/mod/standard/set/all/error.rb

@@ -71,18 +71,16 @@ format :html do
   end
 
   def backtrace_link exception
-    warning_options = {
-      dismissible: true,
-      alert_class: "render-error-message errors-view admin-error-message"
-    }
-    warning = alert("warning", warning_options) do
+    alert_class = "render-error-message errors-view admin-error-message"
+    warning = alert("warning", dismissible: true, alert_class: alert_class) do
       %{
         <h3>Error message (visible to admin only)</h3>
         <p><strong>#{exception.message}</strong></p>
         <div>#{exception.backtrace * "<br>\n"}</div>
       }
     end
-    card_link(error_cardname, class: "render-error-link") + warning
+    link = link_to_card error_cardname, nil, class: "render-error-link"
+    link + warning
   end
 
   view :unsupported_view, perms: :none, tags: :unknown_ok do |args|
@@ -102,15 +100,11 @@ format :html do
 
   view :missing do |args|
     return "" unless card.ok? :create  # should this be moved into ok_view?
-
-    link_opts = {
-      remote: true,
-      class: "slotter missing-#{args[:denied_view] || args[:home_view]}"
-    }
-    link_opts[:path_opts] = { type: args[:type] } if args[:type]
-
+    missing_view = args[:denied_view] || args[:home_view]
     wrap args do
-      view_link "Add #{fancy_title args[:title]}", :new, link_opts
+      link_to_view :new, "Add #{fancy_title args[:title]}",
+                   path: (args[:type] ? { type: args[:type] } : {}),
+                   class: "slotter missing-#{missing_view}"
     end
   end
 
@@ -119,7 +113,7 @@ format :html do
   end
 
   view :conflict, error_code: 409 do |args|
-    actor_link = card_link card.last_action.act.actor.cardname
+    actor_link = link_to_card card.last_action.act.actor.cardname
     expanded_act = wrap(args) do
       _render_act_expanded act: card.last_action.act, current_rev_nr: 0
     end
@@ -158,8 +152,8 @@ format :html do
   view :not_found do |args| # ug.  bad name.
     sign_in_or_up_links =
       unless Auth.signed_in?
-        signin_link = card_link :signin, text: "Sign in"
-        signup_link = link_to "Sign up", card_path("new/:signup")
+        signin_link = link_to_card :signin, "Sign in"
+        signup_link = link_to "Sign up", path: { account: :new, type: :signup }
         %(<div>#{signin_link} or #{signup_link} to create it.</div>)
       end
     frame args.merge(title: "Not Found", optional_menu: :never) do
@@ -186,10 +180,11 @@ format :html do
           when Auth.signed_in?
             "You need permission #{to_task}"
           else
-            signin_link = link_to "sign in", card_url(":signin")
+            signin_link = link_to_card :signin, "sign in"
             or_signup_link =
               if Card.new(type_id: Card::SignupID).ok? :create
-                "or " + link_to("sign up", card_url("new/:signup"))
+                "or " +
+                  link_to("sign up", path: { account: "new", type: :signup })
               end
             Env.save_interrupted_action(request.env["REQUEST_URI"])
             "Please #{signin_link} #{or_signup_link} #{to_task}"

data/mod/standard/set/all/links.rb

@@ -1,9 +1,30 @@
-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={}
-    href = interpret_href href
+RESOURCE_TYPE_REGEXP = /^([a-zA-Z][\-+\.a-zA-Z\d]*):/
+
+format :html do
+  def link_to text=nil, opts={}
+    opts[:href] = interpret_pathish opts.delete(:path)
+    text = raw(text || opts[:href])
+    interpret_data_opts_to_link_to opts
+    content_tag :a, text, opts
+  end
+
+  def interpret_data_opts_to_link_to opts
+    [:remote, :method].each do |key|
+      next unless (val = opts.delete key)
+      opts["data-#{key}"] = val
+    end
+  end
+end
+
+format :css do
+  def link_to _text=nil, opts={}
+    card_url interpret_pathish(opts.delete(:path))
+  end
+end
 
+format do
+  def link_to text=nil, opts={}
+    href = interpret_pathish opts.delete(:path)
     if text && href != text
       "#{text}[#{href}]"
     else
@@ -11,148 +32,156 @@ format do
     end
   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].is_a? String
-        target[:related] = { name: "+#{target[:related]}" }
-      end
-      view_link link_text, :related, html_args.merge(path_opts: target)
-    elsif target[:web]
+  def smart_link_to text, opts={}
+    if (linktype = [:view, :related, :card, :resource].find { |key| opts[key] })
+      send "link_to_#{linktype}", opts.delete(linktype), text, opts
     else
-      link_to link_text, target, html_args
+      send :link_to, text, opts
+    end
+  end
+
+  def link_to_resource resource, text=nil, opts={}
+    case (resource_type = resource_type resource)
+    when "external-link" then opts[:target] = "_blank"
+    when "internal-link" then resource = internal_url resource[1..-1]
+    end
+    add_class opts, resource_type
+    link_to text, opts.merge(path: resource)
+  end
+
+  def resource_type resource
+    case resource
+    when /^https?\:/          then "external-link"
+    when %r{^/}               then "internal-link"
+    when /^mailto\:/          then "email-link"
+    when RESOURCE_TYPE_REGEXP then Regexp.last_match(1) + "-link"
     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?\:/
-        opts[:target] = "_blank"
-        "external-link"
-      when /^mailto\:/
-        "email-link"
-      when /^([a-zA-Z][\-+\.a-zA-Z\d]*):/
-        Regexp.last_match(1) + "-link"
-      when %r{^/}
-        href = internal_url href[1..-1]
-        "internal-link"
-      else
-        return card_link href, opts
-      end
-    add_class opts, new_class
-    link_to text, href, opts
-  end
-
-  # 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
-    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")
-    link_to text, path_opts, opts
+  def link_to_card cardish, text=nil, opts={}
+    opts[:path] ||= {}
+    name = opts[:path][:name] = Card::Name.cardish cardish
+    # @fixme - need smarter mark handling
+
+    text ||= name.to_name.to_show @context_names
+    add_known_or_wanted_class opts, name
+    link_to text, opts
+  end
+
+  def add_known_or_wanted_class opts, name
+    known = opts.delete :known
+    known = Card.known?(name) if known.nil?
+    add_class opts, (known ? "known-card" : "wanted-card")
   end
 
   # link to a specific view (defaults to current card)
   # this is generally used for ajax calls
-  def view_link text, view, opts={}
-    path_opts = opts.delete(:path_opts) || {}
-    path_opts[:view] = view unless view == :home
-    opts[:remote] = true
-    opts[:rel] = "nofollow"
-
-    link_to text, path_opts, opts
-  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
-    opts[:path_opts] ||= { view: :related }
-    opts[:path_opts][:related] = { name: "+#{name}" }
-    opts[:path_opts][:related].merge! opts[:related_opts] if opts[:related_opts]
-    view_link(opts[:text] || name, :related, opts)
-  end
-
-  def path opts={}
-    if opts[:action] == :new && opts[:type] &&
-       !(opts[:name] || opts[:card] || opts[:id])
-      opts.delete(:action)
-      base = "new/#{opts.delete(:type)}"
-    else
-      name = opts.delete(:name) || card.name
-      base = opts[:action] ? "card/#{opts.delete :action}/" : ""
+  def link_to_view view, text, opts={}
+    opts.reverse_merge! path: {}, remote: true, rel: "nofollow"
+    opts[:path][:view] = view unless view == :home
+    link_to text, opts
+  end
 
-      opts[:no_id] = true if [:new, :create].member? opts[:action]
-      # generalize. dislike hardcoding views/actions here
+  def link_to_related cardish, text=nil, opts={}
+    name = Card::Name.cardish cardish
+    opts[:path] ||= {}
+    opts[:path][:related] ||= {}
+    opts[:path][:related][:name] ||= "+#{name}"
+    link_to_view :related, (text || name), opts
+  end
 
-      linkname = name.to_name.url_key
-      unless name.empty? || opts.delete(:no_id)
-        base += (opts[:id] ? "~#{opts.delete :id}" : linkname)
-      end
+  # @param opts [Hash]
+  # @option opts [Symbol] :action card action (:create, :update, :delete)
+  # @option opts [Integer, String] :id
+  # @option opts [String, Card::Name] :name
+  # @option opts [String] :type
+  # @option opts [Hash] :card
+  # @param mark_type [Symbol] defaults to :id
+  def path opts={}, mark_type=:id
+    path = new_cardtype_path(opts) || standard_path(opts, mark_type)
+    internal_url path
+  end
 
-      process_path_card_opts opts, name, linkname
-    end
+  def new_cardtype_path opts
+    return unless opts[:action] == :new
+    opts.delete :action
+    return unless (type_mark = opts.delete(:type))
+    "new/#{Card.quick_fetch(type_mark).cardname.url_key}"
+  end
 
-    query = opts.empty? ? "" : "?#{opts.to_param}"
-    internal_url(base + query)
+  def standard_path opts, mark_type
+    standardize_action! opts
+    base = path_action(opts[:action]) + path_mark(opts, mark_type)
+    base + path_query(opts)
   end
 
-  def internal_url relative_path
-    card_path relative_path
+  def path_action action
+    case action
+    when :create then "card/#{action}/"
+    # sometimes create action has no mark,
+    # but /create alone would refer to a card named "create"
+    when nil     then ""
+    else              "#{action}/"
+    end
   end
 
-  def interpret_href href
-    href.is_a?(Hash) ? path(href) : href
+  def standardize_action! opts
+    return if [:create, :update, :delete].member? opts[:action]
+    opts.delete :action
   end
 
-  def process_path_card_opts opts, name, linkname
-    opts[:card] ||= {}
-    if opts.delete(:known) == false && name.present? && name.to_s != linkname
-      opts[:card][:name] = name
+  def path_mark opts, mark_type
+    case mark_type
+    when :id       && (id = path_id opts)        then "~#{id}"
+    when :codename && (codename = card.codename) then ":#{codename}"
+    else (opts[:name] || card.name).to_name.url_key
     end
+  end
+
+  def path_id opts
+    id = opts.delete :id
+    id if id.present?
+  end
+
+  def path_query opts
+    finalize_card_opts opts.delete(:card), opts
+    opts.delete :action
+    opts.empty? ? "" : "?#{opts.to_param}"
+  end
 
-    if (type = opts.delete(:type)) && Card.known?(type)
-      opts[:card][:type] = type
+  def finalize_card_opts card_opts, opts
+    card_opts ||= {}
+    [:name, :type].each do |field|
+      assign_path_card_opt card_opts, field, opts
     end
-    opts.delete(:card) if opts[:card].empty?
+    opts[:card] = card_opts unless card_opts.empty?
   end
-end
 
-format :html do
-  def link_to text, href, opts={}
-    href = interpret_href href
+  def assign_path_card_opt card_opts, field, opts
+    optvalue = opts.delete field
+    return if card_opts[field] || !optvalue.present?
+    new_value = send "new_#{field}_in_path_opts", optvalue.to_s, opts
+    return unless new_value
+    card_opts[field] = new_value
+  end
 
-    [:remote, :method].each do |key|
-      if (val = opts.delete(key))
-        opts["data-#{key}"] = val
-      end
+  def new_name_in_path_opts name, opts
+    if opts[:action] == :update
+      name if name != card.name
+    elsif !Card.known?(name) && name != name.to_name.url_key
+      name
     end
+  end
 
-    content_tag :a, raw(text), opts.merge(href: href)
+  def new_type_in_path_opts opttype, _opts
+    opttype if Card.known?(opttype)
   end
-end
 
-format :css do
-  def link_to _text, href, _opts={}
-    card_url interpret_href(href)
+  def internal_url relative_path
+    card_path relative_path
+  end
+
+  def interpret_pathish pathish
+    pathish.is_a?(Hash) ? path(pathish) : pathish
   end
 end