card-mod-format 0.11.0

data/set/all/links.rb

@@ -0,0 +1,149 @@
+RESOURCE_TYPE_REGEXP = /^([a-zA-Z][\-+\.a-zA-Z\d]*):/
+
+# The #link_to methods support smart formatting of links in multiple formats.
+format do
+  # 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
+
+format :html do
+  # 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

data/set/all/menu.rb

@@ -0,0 +1,129 @@
+format :html do
+  view :menu, denial: :blank, unknown: true do
+    return "" if card.unknown?
+
+    wrap_with :div, class: "card-menu #{menu_link_classes}" do
+      [render_help_link,
+       menu_link,
+       (voo.show?(:bridge_link) ? bridge_link(false) : nil)]
+    end
+  end
+
+  def menu_link
+    case voo.edit
+    when :inline
+      edit_inline_link
+    when :full
+      edit_in_bridge_link
+    else # :standard
+      edit_link
+    end
+  end
+
+  def edit_view
+    case voo.edit
+    when :inline
+      :edit_inline
+    when :full
+      :edit
+    else # :standard
+      edit_link
+    end
+  end
+
+  view :edit_link, unknown: true, denial: :blank do
+    edit_link edit_link_view
+  end
+
+  def edit_link_view
+    :edit
+  end
+
+  view :full_page_link do
+    full_page_link
+  end
+
+  view :bridge_link, unknown: true do
+    bridge_link
+  end
+
+  def bridge_link in_modal=true
+    opts = { class: "bridge-link" }
+    if in_modal
+      # add_class opts, "close"
+      opts["data-slotter-mode"] = "modal-replace"
+    end
+    link_to_view :bridge, material_icon(:more_horiz), opts
+  end
+
+  # no caching because help_text view doesn't cache, and we can't have a
+  # stub in the data-content attribute or it will get html escaped.
+  view :help_link, cache: :never, unknown: true do
+    help_link render_help_text, help_title
+  end
+
+  def help_link text=nil, title=nil
+    opts = help_popover_opts text, title
+    add_class opts, "_card-menu-popover"
+    link_to help_icon, opts
+  end
+
+  def help_popover_opts text=nil, title=nil
+    text ||= render_help_text
+    opts = { "data-placement": :left, class: "help-link" }
+    popover_opts text, title, opts
+  end
+
+  def help_icon
+    material_icon("help")
+  end
+
+  def help_title
+    "#{name_parts_links} (#{render_type}) #{full_page_link unless card.simple?}"
+  end
+
+  def name_parts_links
+    card.name.parts.map do |part|
+      link_to_card part
+    end.join Card::Name.joint
+  end
+
+  def full_page_link
+    link_to_card full_page_card, full_page_icon, class: classy("full-page-link")
+  end
+
+  def full_page_card
+    card
+  end
+
+  def edit_in_bridge_link opts={}
+    edit_link :bridge, opts
+  end
+
+  def edit_link view=:edit, opts={}
+    link_to_view view, opts.delete(:link_text) || menu_icon,
+                 edit_link_opts(opts.reverse_merge(modal: :lg))
+  end
+
+  # @param modal [Symbol] modal size
+  def edit_link_opts modal: nil
+    opts = { class: classy("edit-link") }
+    if modal
+      opts[:"data-slotter-mode"] = "modal"
+      opts[:"data-modal-class"] = "modal-#{modal}"
+    end
+    opts
+  end
+
+  def menu_link_classes
+    "nodblclick" + (show_view?(:hover_link) ? " _show-on-hover" : "")
+  end
+
+  def menu_icon
+    material_icon "edit"
+  end
+
+  def full_page_icon
+    icon_tag :open_in_new
+  end
+end

data/set/all/meta_tags.haml

@@ -0,0 +1,4 @@
+%meta{ charset: "UTF-8" }
+%meta{ content: "width=device-width, initial-scale=1.0", name: "viewport" }
+- if card.unknown?
+  %meta{ content: "noindex", name: "robots"}

data/set/all/path.rb

@@ -0,0 +1,78 @@
+format do
+  # Decko uses the term "path" a bit unusually.
+  #
+  # In most formats, #path returns a full url.  In HTML, it provides everything after
+  # the domain/port.
+  #
+  # If you're feeling saucy, 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" is easy to type and the method 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: :bar   -> "current?view=bar"
+  #   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
+
+  def path opts={}
+    return opts unless opts.is_a? Hash
+    path = Card::Path.new(card, opts)&.render
+    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
+end
+
+format :json do
+  def add_unknown_name_to_opts name, opts
+    # noop
+  end
+end
+
+format :css do
+  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
+
+format :html do
+  # in HTML, decko paths rendered as relative to the site's root.
+  def contextualize_path relative_path
+    card_path relative_path
+  end
+end
+
+format :email_html do
+  def contextualize_path relative_path
+    card_url relative_path
+  end
+end

data/set/all/rich_html.rb

@@ -0,0 +1,4 @@
+format :html do
+  delegate :class_up, :class_down, :with_class_up, :without_upped_class, :classy,
+           to: :voo
+end

data/set/all/rss.rb

@@ -0,0 +1,76 @@
+format :rss do
+  attr_accessor :xml
+
+  def initialize card, args
+    super
+    @xml = @parent ? @parent.xml : ::Builder::XmlMarkup.new
+  end
+
+  def show view, args
+    view ||= :feed
+    render! view, args
+  end
+
+  # FIXME: integrate this with common XML features when it is added
+  view :feed, cache: :never do
+    return "RSS feeds disabled" unless Cardio.config.rss_enabled
+    begin
+      @xml.instruct! :xml, version: "1.0", standalone: "yes"
+      @xml.rss version: "2.0",
+               "xmlns:content" => "http://purl.org/rss/1.0/modules/content/" do
+        @xml.channel do
+          @xml.title       render_feed_title
+          @xml.description render_feed_description
+          @xml.link        render_url
+          render_feed_body
+        end
+      end
+    rescue => e
+      @xml.error "\n\nERROR rendering RSS: #{e.inspect}\n\n #{e.backtrace}"
+    end
+  end
+
+  def raw_feed_items
+    [card]
+  end
+
+  view :feed_body, cache: :never do
+    raw_feed_items.each do |item|
+      @xml.item do
+        subformat(item).render! :feed_item
+      end
+    end
+  end
+
+  view :feed_title do
+    Card::Rule.global_setting(:title) + " : " + card.name.gsub(/^\*/, "")
+  end
+
+  view :feed_item do
+    @xml.title card.name
+    add_name_context
+    @xml.description render_feed_item_description
+    @xml.pubDate pub_date
+    @xml.link render_url
+    @xml.guid render_url
+  end
+
+  def pub_date
+    (card.updated_at || Time.zone.now).to_s(:rfc822)
+    # updated_at fails on virtual
+    # cards, because not all to_s's take args (just actual dates)
+  end
+
+  view :feed_item_description do
+    render_open_content
+  end
+
+  view(:feed_description) { "" }
+  view(:comment_box) { "" }
+  view(:menu) { "" }
+
+  view :open,         :titled, mod: All::Base::Format
+  view :content,      :core,   mod: All::Base::Format
+  view :open_content, :core,   mod: All::Base::Format
+  view :closed,       :link,   mod: All::Base::Format
+end

data/set/all/text.rb

@@ -0,0 +1,7 @@
+
+format :text do
+  view :core do
+    HTMLEntities.new.decode strip_tags(super()).to_s
+    # need this string method to get out of html_safe mode
+  end
+end