card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod021-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
+    "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 ~~

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

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (RichHtml)
+#
+module RichHtml;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  delegate :class_up, :class_down, :with_class_up, :without_upped_class, :classy,
+           to: :voo
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html.rb ~~

data/tmpsets/set/mod021-standard/all/rich_html/alert.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module RichHtml;
+# Set: All cards (RichHtml, Alert)
+#
+module Alert;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/alert.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  # alert_types: 'success', 'info', 'warning', 'danger'
+  def alert alert_type, dismissable=false, disappear=false, args={}
+    add_class args, alert_classes(alert_type, dismissable, disappear)
+    wrap_with :div, args.merge(role: "alert") do
+      [(alert_close_button if dismissable), output(yield)]
+    end
+  end
+
+  def alert_classes alert_type, dismissable, disappear
+    classes = ["alert", "alert-#{alert_type}"]
+    classes << "alert-dismissible " if dismissable
+    classes << "_disappear" if disappear
+    classy classes
+  end
+
+  def alert_close_button
+    wrap_with :button, type: "button", "data-dismiss": "alert",
+                       class: "close", "aria-label": "Close" do
+      wrap_with :span, "&times;", "aria-hidden" => true
+    end
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/alert.rb ~~

data/tmpsets/set/mod021-standard/all/rich_html/content.rb

@@ -0,0 +1,144 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module RichHtml;
+# Set: All cards (RichHtml, Content)
+#
+module Content;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/content.rb"; end
+def show_comment_box_in_related?
+  false
+end
+
+def help_rule_card
+  setting = new_card? ? [:add_help, { fallback: :help }] : :help
+  help_card = rule_card(*setting)
+  help_card if help_card&.ok?(:read)
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def prepare_content_slot
+    class_up "card-slot", "d0-card-content"
+    voo.hide :menu
+  end
+
+  before(:content) { prepare_content_slot }
+
+  view :content do
+    wrap { [_render_menu, _render_core] }
+  end
+
+  view :short_content, wrap: { div: { class: "text-muted" } } do
+    short_content
+  end
+
+  before(:content_with_title) { prepare_content_slot }
+
+  view :content_with_title do
+    wrap true, title: card.format(:text).render_core do
+      [_render_menu, _render_core]
+    end
+  end
+
+  before :content_panel do
+    prepare_content_slot
+    class_up "card-slot", "card"
+  end
+
+  view :content_panel do
+    wrap do
+      wrap_with :div, class: "card-body" do
+        [_render_menu, _render_core]
+      end
+    end
+  end
+
+  view :titled, commentable: true do
+    @content_body = true
+    wrap do
+      [
+        naming { render_header },
+        render_flash,
+        wrap_body { render_titled_content },
+        render_comment_box
+      ]
+    end
+  end
+
+  view :labeled, unknown: true do
+    @content_body = true
+    wrap(true, class: "row") do
+      labeled(render_title, wrap_body { "#{render_menu}#{render_labeled_content}" } )
+    end
+  end
+
+  def labeled label, content
+    haml :labeled, label: label, content: content
+  end
+
+  view :open, commentable: true do
+    toggle_logic
+    @toggle_mode = :open
+    @content_body = true
+    frame do
+      [_render_open_content, render_comment_box]
+    end
+  end
+
+  view :closed do
+    with_nest_mode :closed do
+      toggle_logic
+      voo.hide :closed_content
+      class_up "d0-card-body", "closed-content"
+      @content_body = false
+      @toggle_mode = :close
+      frame
+    end
+  end
+
+  def toggle_logic
+    show_view?(:title_link, :hide) ? voo.show(:icon_toggle) : voo.show(:title_toggle)
+  end
+
+  def current_set_card
+    set_name = params[:current_set]
+    set_name ||= "#{card.name}+*type" if card.known? && card.type_id == Card::CardtypeID
+    set_name ||= "#{card.name}+*self"
+    Card.fetch(set_name)
+  end
+
+  # LOCALIZE
+  def short_content
+    short_content_items || short_content_fields || short_content_from_core
+  end
+
+  def short_content_items
+    return unless card.respond_to? :count
+    "#{count} #{'item'.pluralize count}"
+  end
+
+  def short_content_fields
+    return unless voo.structure || card.structure
+    fields = nested_fields.size
+    return if fields.zero?
+    "#{fields} #{'field'.pluralize fields}"
+  end
+
+  def short_content_from_core
+    content = render_core
+    if content.blank?
+      "empty"
+    elsif content.size <= 5
+      content
+    elsif content.count("\n") < 2
+      "#{content.size} characters"
+    else
+      "#{content.count("\n") + 1} lines"
+    end
+  end
+
+  def count
+    @count ||= card.count
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/content.rb ~~

data/tmpsets/set/mod021-standard/all/rich_html/error.rb

@@ -0,0 +1,211 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module RichHtml;
+# Set: All cards (RichHtml, Error)
+#
+module Error;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/error.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :server_error, template: :haml
+
+  view :debug_server_error, wrap: { modal: { size: :full } } do
+    error_page = BetterErrors::ErrorPage.new Card::Error.current,
+                                             "PATH_INFO" => request.env["REQUEST_URI"]
+    haml :debug_server_error, {}, error_page
+  end
+
+  view :message, perms: :none, unknown: true do
+    frame { params[:message] }
+  end
+
+  view :missing do
+    createable do
+      wrap { missing_link("#{fa_icon 'plus-square'} #{_render_title}") }
+    end
+  end
+
+  def createable
+    card.ok?(:create) ? yield : ""
+  end
+
+  def missing_link text
+    path_opts = voo.type ? { card: { type: voo.type } } : {}
+    link_to_view :new, text, path: path_opts, class: "missing-link"
+  end
+
+  view :closed_missing, perms: :none do
+    wrap_with :span, h(title_in_context), class: "faint"
+  end
+
+  view :conflict, cache: :never do
+    actor_link = link_to_card card.last_action.act.actor.name
+    class_up "card-slot", "error-view"
+    wrap do # ENGLISH below
+      alert "warning" do
+        %(
+          <strong>Conflict!</strong>
+          <span class="new-current-revision-id">#{card.last_action_id}</span>
+          <div>#{actor_link} has also been making changes.</div>
+          <div>Please examine below, resolve above, and re-submit.</div>
+          #{render_act}
+        )
+      end
+    end
+  end
+
+  view :errors, perms: :none do
+    return if card.errors.empty?
+
+    voo.title = card.name.blank? ? "Problems" : tr(:problems_name, cardname: card.name)
+    voo.hide! :menu
+    class_up "alert", "card-error-msg"
+    standard_errors voo.title
+  end
+
+  view :not_found do
+    voo.hide! :menu
+    voo.title = "Not Found"
+    frame do
+      [not_found_errors, sign_in_or_up_links("to create it")]
+    end
+  end
+
+  view :denial do
+    focal? ? loud_denial : quiet_denial
+  end
+
+  def view_for_unknown view
+    case
+    when main? && ok?(:create) then :new
+    when commentable?(view)    then view
+    else super
+    end
+  end
+
+  def commentable? view
+    return false unless view_setting(:commentable, view) &&
+                        show_view?(:comment_box, :hide)
+
+    ok? :comment
+  end
+
+  def show_all_errors?
+    # make configurable by env
+    Auth.always_ok? || Rails.env.development?
+  end
+
+  def error_cardname exception
+    cardname = super
+    show_all_errors? ? backtrace_link(cardname, exception) : cardname
+  end
+
+  def rendering_error exception, view
+    wrap_with(:span, class: "render-error alert alert-danger") { super }
+  end
+
+  def error_modal_id
+    @error_modal_id ||= unique_id
+  end
+
+  def error_message exception
+    %{
+      <h3>Error message (visible to admin only)</h3>
+      <p><strong>#{CGI.escapeHTML exception.message}</strong></p>
+      <div>#{exception.backtrace * "<br>\n"}</div>
+    }
+  end
+
+  def backtrace_link cardname, exception
+    # TODO: make this a modal link after new modal handling is merged in
+    wrap_with(:span, title: error_message(exception)) { cardname }
+  end
+
+  def standard_errors heading=nil
+    alert "warning", true do
+      [
+        (wrap_with(:h4, heading, class: "alert-heading") if heading),
+        error_messages.join("<hr>")
+      ]
+    end
+  end
+
+  def error_messages
+    card.errors.map do |attrib, msg|
+      attrib == :abort ? h(msg) : standard_error_message(attrib, msg)
+    end
+  end
+
+  def standard_error_message attribute, message
+    "<div><strong>#{h attribute.to_s.upcase}:</strong> #{h message}</div>"
+  end
+
+  def not_found_errors
+    if card.errors.any?
+      standard_errors
+    else
+      haml :not_found
+    end
+  end
+
+  def sign_in_or_up_links to_task
+    return if Auth.signed_in?
+
+    links = [signin_link, signup_link].compact.join " #{tr :or} "
+    wrap_with(:div) do
+      [tr(:please), links, to_task].join(" ") + "."
+    end
+  end
+
+  def signin_link
+    link_to_card :signin, tr(:sign_in), remote: true, class: "slotter"
+  end
+
+  def signup_link
+    return unless signup_ok?
+
+    link_to tr(:sign_up), path: { action: :new, mark: :signup },
+                              remote: true, class: "slotter"
+  end
+
+  def signup_ok?
+    Card.new(type_id: Card::SignupID).ok? :create
+  end
+
+  def quiet_denial
+    wrap_with :span, class: "denied" do
+      "<!-- Sorry, you don't have permission (#{@denied_task}) -->"
+    end
+  end
+
+  def loud_denial
+    voo.hide :menu
+    frame do
+      [wrap_with(:h1, tr(:sorry)),
+       wrap_with(:div, loud_denial_message)]
+    end
+  end
+
+  def loud_denial_message
+    to_task = @denied_task ? tr(:denied_task, denied_task: @denied_task) : tr(:to_do_that)
+
+    case
+    when not_denied_task_read?
+      tr(:read_only)
+    when Auth.signed_in?
+      tr(:need_permission_task, task: to_task)
+    else
+      Env.save_interrupted_action request.env["REQUEST_URI"]
+      sign_in_or_up_links to_do_unauthorized_task
+    end
+  end
+
+  def not_denied_task_read?
+    @denied_task != :read && Card.config.read_only
+  end
+
+  def to_do_unauthorized_task
+    @denied_task ? tr(:denied_task, denied_task: @denied_task) : tr(:to_do_that)
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/standard/set/all/rich_html/error.rb ~~