card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod020-search/type/search_type.rb

@@ -0,0 +1,88 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Type
+# Set: All "SearchType" cards
+#
+module SearchType;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/type/search_type.rb"; end
+include_set Type::Json
+include_set Abstract::WqlSearch
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  view :core, cache: :never do
+    _render search_result_view
+  end
+
+  def chunk_list
+    :query
+  end
+
+  def search_result_view
+    case search_with_params
+    when Exception              then :search_error
+    when Integer                then :search_count
+    when nest_mode == :template then :raw
+    else                         :card_list
+    end
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  def items_for_export
+    return [] if card.content.empty? || unexportable_tag?(card.name.tag_name.key)
+    card.item_cards
+  end
+
+  # avoid running the search from +*options (huge results) and +*structure (errors)
+  # TODO: make this configurable in set mods
+  def unexportable_tag? tag_key
+    %i[options structure].map { |code| code.cardname.key }.include? tag_key
+  end
+end
+
+module RssFormat; parent.send :register_set_format, Card::Format::RssFormat, self; extend Card::Set::AbstractFormat
+  view :feed_body do
+    case raw_feed_items
+    when Exception then @xml.item(render!(:search_error))
+    when Integer then @xml.item(render!(:search_count))
+    else super()
+    end
+  end
+
+  def raw_feed_items
+    @raw_feed_items ||= search_with_params
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :core do
+    _render search_result_view
+  end
+
+  view :closed do
+    voo.hide :closed_content
+    super()
+  end
+
+  view :closed_content, cache: :never do
+    if depth > max_depth
+      "..."
+    else
+      search_params[:limit] = closed_limit
+      _render_core hide: "paging", items: { view: :link }
+      # TODO: if item is queryified to be "name", then that should work.
+      # otherwise use link
+    end
+  end
+
+  def rss_link_tag
+    path_opts = { format: :rss }
+    Array(search_params[:vars]).compact.each { |k, v| opts["_#{k}"] = v }
+    tag "link", rel: "alternate",
+                type: "application/rss+xml",
+                title: "RSS",
+                href: path(path_opts)
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/type/search_type.rb ~~

data/tmpsets/set/mod021-standard/all/comment.rb

@@ -0,0 +1,88 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Comment)
+#
+module Comment;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/comment.rb"; end
+def commenting?
+  comment && @action != :delete
+end
+
+event :add_comment, :prepare_to_store, on: :save, when: :comment do
+  Env.session[:comment_author] = comment_author if Env.session
+  return unless comment.present?
+  self.content =
+    [content, format.comment_with_signature].compact.join "\n<hr\>\n"
+end
+
+attr_writer :comment_author
+
+def comment_author
+  @comment_author ||=
+    Env.session[:comment_author] || Env.params[:comment_author] || "Anonymous"
+end
+
+def clean_comment
+  comment.split(/\n/).map do |line|
+    "<p>#{line.strip.empty? ? '&nbsp;' : line}</p>"
+  end * "\n"
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def comment_with_signature
+    card.clean_comment + "\n" + comment_signature
+  end
+
+  def comment_signature
+    wrap_with :div, class: "w-comment-author" do
+      "#{comment_author}.....#{Time.zone.now}"
+    end
+  end
+
+  def comment_author
+    if Auth.signed_in?
+      "[[#{Auth.current.name}]]"
+    else
+      "#{card.comment_author} (Not signed in)"
+    end
+  end
+
+  view :comment_box, denial: :blank, unknown: true, perms: :comment do
+    wrap_with :div, class: "comment-box nodblclick" do
+      action = card.new_card? ? :create : :update
+      card_form action do
+        [hidden_comment_fields, comment_box, comment_buttons]
+      end
+    end
+  end
+
+  def hidden_comment_fields
+    return unless card.new_card?
+    hidden_field_tag "card[name]", card.name
+    # FIXME: wish we had more generalized solution for names.
+    # without this, nonexistent cards will often take left's linkname.
+    # (needs test)
+  end
+
+  def comment_box
+    text_area :comment, rows: 3
+  end
+
+  def comment_buttons
+    wrap_with :div, class: "comment-buttons" do
+      [comment_author_label, comment_submit_button]
+    end
+  end
+
+  def comment_author_label
+    return if Auth.signed_in?
+    %(<label>My Name is:</label> #{text_field :comment_author})
+  end
+
+  def comment_submit_button
+    submit_button text: "Comment", type: :submit, disable_with: "Commenting"
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/comment.rb ~~

data/tmpsets/set/mod021-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 :closed_missing, perms: :none, closed: true do
+    ""
+  end
+
+  view :missing, 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/mod021-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 → mod021-standard}/all/list_changes.rb

@@ -1,7 +1,11 @@
 # -*- 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")
@@ -16,10 +20,14 @@ def linker_lists
               "lists that link to #{name}")
 end
 
+def codename_list_exist?
+  Card::Codename.exists? :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
+      when: :codename_list_exist? do
+  type_key_was = (tk = Card.quick_fetch(type_id_before_last_save)) && tk.key
 
   list_fields.each do |card|
     card.update_listed_by_cache_for card.item_keys, type_key: type_key_was
@@ -30,7 +38,7 @@ end
 
 event :trunk_name_of_a_list_relation_changed, :finalize,
       changed: :name,  on: :update,
-      when: proc { Codename[:list] } do
+      when: :codename_list_exist? do
   list_fields.each do |card|
     card.update_listed_by_cache_for card.item_keys
   end
@@ -39,7 +47,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 +55,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 ~~