card 1.99.6 → 1.100.0

data/tmpsets/set/mod022-standard/all/error.rb

@@ -0,0 +1,85 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Error)
+#
+module Error;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/error.rb"; end
+def copy_errors card
+  card.errors.each do |att, msg|
+    errors.add att, msg
+  end
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  view :compact_missing, perms: :none, compact: true do
+    ""
+  end
+
+  view :unknown, perms: :none, cache: :never do
+    ""
+  end
+
+  view :server_error, perms: :none do
+    tr(:server_error)
+  end
+
+  view :denial, perms: :none do
+    focal? ? tr(:denial) : ""
+  end
+
+  view :not_found, perms: :none do
+    error_name = card.name.present? ? safe_name : tr(:not_found_no_name)
+    tr(:not_found_named, cardname: error_name)
+  end
+
+  view :bad_address, perms: :none do
+    root.error_status = 404
+    tr(:bad_address)
+  end
+
+  view :errors do
+    ["Problem:", "", standard_errors].flatten.join "\n"
+  end
+
+  def standard_errors
+    card.errors.map do |attrib, msg|
+      attrib == :abort ? msg : standard_error_message(attrib, msg)
+    end
+  end
+
+  # for override
+  def standard_error_message attribute, message
+    "#{attribute.to_s.upcase}: #{message}"
+  end
+
+  def unsupported_view_error_message view
+    tr(:unsupported_view, view: view, cardname: card.name)
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  view :errors do
+    format_error error_list
+  end
+
+  view :server_error, :errors
+  view :denial, :errors
+  view :not_found, :errors
+
+  view :bad_address do
+    format_error super()
+  end
+
+  def format_error error
+    { error_status: error_status, errors: error }
+  end
+
+  def error_list
+    card.errors.each_with_object([]) do |(field, message), list|
+      list << { field: field, message: message }
+    end
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/error.rb ~~

data/tmpsets/set/mod022-standard/all/links.rb

@@ -0,0 +1,158 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Links)
+#
+module Links;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/links.rb"; end
+RESOURCE_TYPE_REGEXP = /^([a-zA-Z][\-+\.a-zA-Z\d]*):/
+
+# The #link_to methods support smart formatting of links in multiple formats.
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  # Creates a "link", the meaning of which depends upon the format.  In this base
+  # format, the link looks like [text][absolute path]
+  #
+  # @param text [String] optional string associated with link
+  # @param opts [Hash] optional Hash. In simple formats, :path is usually the only key
+  def link_to text=nil, opts={}
+    path = path((opts.delete(:path) || {}))
+    if text && path != text
+      "#{text}[#{path}]"
+    else
+      path
+    end
+  end
+
+  # link to a different view of the current card
+  # @param view [Symbol,String]
+  # @param text [String]
+  # @param opts [Hash]
+  def link_to_view view, text=nil, opts={}
+    add_to_path opts, view: view unless view == :home
+    link_to text, opts
+  end
+
+  # link to a card other than the current card.
+  # @param cardish [Integer, Symbol, String, Card] a card identifier
+  # @param text [String]
+  # @param opts [Hash]
+  def link_to_card cardish, text=nil, opts={}
+    add_to_path opts, mark: Card::Name[cardish]
+    link_to text, opts
+  end
+
+  # a "resource" is essentially a reference to something that
+  # decko doesn't recognize to be a card.  Can be a remote url,
+  # a local url (that decko hasn't parsed) or a local path.
+  # @param resource [String]
+  # @param text [String]
+  # @param opts [Hash]
+  def link_to_resource resource, text=nil, opts={}
+    resource = clean_resource resource, resource_type(resource)
+    link_to text, opts.merge(path: resource)
+  end
+
+  # smart_link_to is wrapper method for #link_to, #link_to_card, #link_to_view, and
+  # #link_to_resource.  If the opts argument contains :view, :related, :card, or
+  # :resource, it will use the respective method to render a link.
+  #
+  # This is usually most useful when writing views that generate many different
+  # kinds of links.
+  def smart_link_to text, opts={}
+    if (linktype = %i[view card resource].find { |key| opts[key] })
+      send "link_to_#{linktype}", opts.delete(linktype), text, opts
+    else
+      send :link_to, text, opts
+    end
+  end
+
+  private
+
+  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
+
+  def clean_resource resource, resource_type
+    if resource_type == "internal-link"
+      contextualize_path resource[1..-1]
+    else
+      resource
+    end
+  end
+
+  def add_to_path opts, new_hash
+    opts[:path] = (opts[:path] || {}).merge new_hash
+  end
+end
+
+public
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  # in HTML, #link_to renders an anchor tag <a>
+  # it treats opts other than "path" as html opts for that tag,
+  # and it adds special handling of "remote" and "method" opts
+  # (changes them into data attributes)
+  def link_to text=nil, opts={}
+    opts[:href] ||= path opts.delete(:path)
+    text = raw(text || opts[:href])
+    interpret_data_opts_to_link_to opts
+    wrap_with :a, text, opts
+  end
+
+  # in HTML, #link_to_card adds special css classes indicated whether a
+  # card is "known" (real or virtual) or "wanted" (unknown)
+  # TODO: upgrade from (known/wanted)-card to (real/virtual/unknown)-card
+  def link_to_card cardish, text=nil, opts={}
+    name = Card::Name[cardish]
+    slotterify opts if opts[:slotter]
+    add_known_or_wanted_class opts, name
+    super name, (text || name), opts
+  end
+
+  # in HTML, #link_to_view defaults to a remote link with rel="nofollow".
+  def link_to_view view, text=nil, opts={}
+    slotterify opts
+    super view, (text || view), opts
+  end
+
+  # in HTML, #link_to_resource automatically adds a target to external resources
+  # so they will open in another tab. It also adds css classes indicating whether
+  # the resource is internal or external
+  def link_to_resource resource, text=nil, opts={}
+    add_resource_opts opts, resource_type(resource)
+    super
+  end
+
+  private
+
+  def slotterify opts
+    opts.delete(:slotter)
+    opts.reverse_merge! remote: true, rel: "nofollow"
+    add_class opts, "slotter"
+  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
+
+  def interpret_data_opts_to_link_to opts
+    %i[remote method].each do |key|
+      next unless (val = opts.delete key)
+      opts["data-#{key}"] = val
+    end
+  end
+
+  def add_resource_opts opts, resource_type
+    opts[:target] ||= "_blank" if resource_type == "external-link"
+    add_class opts, resource_type
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/links.rb ~~

data/tmpsets/set/{mod016-standard → mod022-standard}/all/list_changes.rb

@@ -1,25 +1,32 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class All; module ListChanges; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/all/list_changes.rb ~~
+class Card; module Set; class All
+# Set: All cards (ListChanges)
+#
 # -*- encoding : utf-8 -*-
+module ListChanges;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/list_changes.rb"; end
 
 def list_fields
-  Card.search({ left: name, type_id: Card::ListID }, "list fields")
+  Card.search({ left: name, type_id: Card::MirroredListID }, "list fields")
 end
 
 def listed_by_fields
-  Card.search({ left: name, type_id: Card::ListedByID }, "listed by fields")
+  Card.search({ left: name, type_id: Card::MirrorListID }, "listed by fields")
 end
 
 def linker_lists
-  Card.search({ type_id: Card::ListID, link_to: name },
+  Card.search({ type_id: Card::MirroredListID, link_to: name },
               "lists that link to #{name}")
 end
 
+def codename_list_exist?
+  Card::Codename.exists?(:mirrored_list) && Card::Codename.exists?(:mirror_list)
+end
+
 event :trunk_cardtype_of_a_list_relation_changed, :finalize,
-      changed: :type, on: :update,
-      when: proc { Codename[:list] } do
-  type_key_was = (tk = Card.quick_fetch(type_id_was)) && tk.key
+      changed: :type, on: :update, when: :codename_list_exist? do
+  type_key_was = Card.quick_fetch(type_id_before_act)&.key
 
   list_fields.each do |card|
     card.update_listed_by_cache_for card.item_keys, type_key: type_key_was
@@ -29,8 +36,8 @@ event :trunk_cardtype_of_a_list_relation_changed, :finalize,
 end
 
 event :trunk_name_of_a_list_relation_changed, :finalize,
-      changed: :name,  on: :update,
-      when: proc { Codename[:list] } do
+      changed: :name, on: :update,
+      when: :codename_list_exist? do
   list_fields.each do |card|
     card.update_listed_by_cache_for card.item_keys
   end
@@ -39,7 +46,7 @@ end
 
 event :cardtype_of_list_item_changed, :validate,
       changed: :type, on: :save,
-      when: proc { Codename[:list] } do
+      when: :codename_list_exist? do
   linker_lists.each do |card|
     next unless card.item_type_id != type_id
     errors.add(:type,
@@ -47,7 +54,5 @@ event :cardtype_of_list_item_changed, :validate,
                "is referenced by list card #{card.name}")
   end
 end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/standard/set/all/list_changes.rb ~~
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/list_changes.rb ~~

data/tmpsets/set/mod022-standard/all/path.rb

@@ -0,0 +1,185 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Path)
+#
+module Path;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/path.rb"; end
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  # Decko uses "path" a bit unusually.  In most formats, it returns a full url.  In HTML,
+  # it provides everything after the domain/port.
+  #
+  # If you're feeling your saucy oats, you might point out that typically "paths" don't
+  # include queries and fragment identifiers, much less protocols, domains, and ports.
+  # 10 pedantry points to you! But "path" has just four letters and is smart about
+  # format needs, so using it will lead you down the right ... something or other.
+
+  # Format#path is for generating standard card routes, eg, assuming the card
+  # associated with the current format is named "current", it will generate paths like
+  # these:
+
+  #   path view: :listing   -> "current?view=listing"
+  #   path mark: [mycardid] -> "mycardname"
+  #   path format: :csv)    -> "current.csv"
+  #   path action: :update  -> "update/current"
+
+  # #path produces paths that follow one of three main patterns:
+
+  #   1. mark[.format][?query]  # standard GET request
+  #   2. action/mark[?query]    # GET variant of standard actions
+  #   3. new/mark               # shortcut for "new" view of cardtype
+
+  # @param opts [Hash, String] a String is treated as a complete path and
+  # bypasses all processing
+  # @option opts [String, Card::Name, Integer, Symbol, Card] :mark
+  # @option opts [Symbol] :action card action (:create, :update, :delete)
+  # @option opts [Symbol] :format
+  # @option opts [Hash] :card
+  # @option opts [TrueClass] :no_mark
+
+  CAST_PARAMS = { slot: { hide: :array, show: :array, wrap: :array } }.freeze
+  # TODO: monkey API for this
+
+  def path opts={}
+    return opts unless opts.is_a? Hash
+    path = new_cardtype_path(opts) || standard_path(opts)
+    contextualize_path path
+  end
+
+  # in base format (and therefore most other formats), even internal paths
+  # are rendered as absolute urls.
+  def contextualize_path relative_path
+    card_url relative_path
+  end
+
+  private
+
+  def new_cardtype_path opts
+    return unless valid_opts_for_new_cardtype_path? opts
+    "#{opts.delete :action}/#{path_mark opts}#{path_query opts}"
+  end
+
+  def valid_opts_for_new_cardtype_path? opts
+    return unless opts[:action].in? %i[new type]
+
+    # "new" and "type" are not really an action and are only
+    # a valid value here for this path
+    opts[:mark].present?
+  end
+
+  def standard_path opts
+    path_base(opts) + path_extension(opts) + path_query(opts)
+  end
+
+  def path_base opts
+    mark = path_mark opts
+    if (action = path_action opts)
+      action_base action, mark
+    else
+      mark
+    end
+  end
+
+  def action_base action, mark
+    mark.present? ? "#{action}/#{mark}" : "card/#{action}"
+    # the card/ prefix prevents interpreting action as cardname
+  end
+
+  def path_action opts
+    return unless (action = opts.delete(:action)&.to_sym)
+    %i[create update delete].find { |a| a == action }
+  end
+
+  def path_mark opts
+    return "" if markless_path? opts
+    name = opts[:mark] ? Card::Name[opts.delete(:mark)] : card.name
+    add_unknown_name_to_opts name.to_name, opts
+    name.to_name.url_key
+  end
+
+  def markless_path? opts
+    opts[:action] == :create || opts.delete(:no_mark)
+  end
+
+  def path_extension opts
+    extension = opts.delete :format
+    extension ? ".#{extension}" : ""
+  end
+
+  def path_query opts
+    opts = cast_path_opts opts
+    opts.empty? ? "" : "?#{opts.to_param}"
+  end
+
+  # normalizes certain path opts to specified data types
+  def cast_path_opts opts, cast_hash=CAST_PARAMS
+    return opts unless opts.is_a?(::Hash)
+    opts.each do |key, value|
+      next unless (cast_to = cast_hash[key])
+      opts[key] = cast_path_value value, cast_to
+    end
+  end
+
+  def cast_path_value value, cast_to
+    if cast_to.is_a? Hash
+      cast_path_opts value, cast_to
+    else
+      send "cast_path_value_as_#{cast_to}", value
+    end
+  end
+
+  def cast_path_value_as_array value
+    Array.wrap value
+  end
+
+  def add_unknown_name_to_opts name, opts
+    return if name_specified?(opts) || name_standardish?(name) || Card.known?(name)
+    opts[:card] ||= {}
+    opts[:card][:name] = name
+  end
+
+  def name_specified? opts
+    opts[:card] && opts[:card][:name]
+  end
+
+  # no name info will be lost by using url_key
+  def name_standardish? name
+    name.s == Card::Name.url_key_to_standard(name.url_key)
+  end
+end
+
+public
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  def add_unknown_name_to_opts name, opts
+    # noop
+  end
+end
+
+module CssFormat; parent.send :register_set_format, Card::Format::CssFormat, self; extend Card::Set::AbstractFormat
+  def contextualize_path relative_path
+    if Card.config.file_storage == :local
+      # absolute paths lead to invalid assets path in css for cukes
+      card_path relative_path
+    else
+      # ...but relative paths are problematic when machine output and
+      # hard-coded assets (like fonts) are on different servers
+      card_url relative_path
+    end
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  # in HTML, decko paths rendered as relative to the site's root.
+  def contextualize_path relative_path
+    card_path relative_path
+  end
+end
+
+module EmailHtmlFormat; parent.send :register_set_format, Card::Format::EmailHtmlFormat, self; extend Card::Set::AbstractFormat
+  def contextualize_path relative_path
+    card_url relative_path
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/path.rb ~~