card 1.99.4 → 1.99.5

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

@@ -1,88 +0,0 @@
-# -*- 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

@@ -1,88 +0,0 @@
-# -*- 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

@@ -1,85 +0,0 @@
-# -*- 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

@@ -1,158 +0,0 @@
-# -*- 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/mod021-standard/all/path.rb

@@ -1,185 +0,0 @@
-# -*- 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
-    "new/#{path_mark opts}#{path_query opts}"
-  end
-
-  def valid_opts_for_new_cardtype_path? opts
-    return unless opts[:action] == :new
-    opts.delete :action
-    # "new" is not really an action and is 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_simple?(name) || Card.known?(name)
-    opts[:card] ||= {}
-    opts[:card][:name] = name
-  end
-
-  def name_specified? opts
-    opts[:card] && opts[:card][:name]
-  end
-
-  # name is same as url_key, so the url_key won't lose any info
-  def name_simple? 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 ~~