card 1.101.2 → 1.102.0

data/tmpsets/set/mod008-card-mod-format/all/error.rb

@@ -1,88 +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-format/set/all/error.rb"; end
-module Format; module_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:", "", error_messages].flatten.join "\n"
-  end
-
-  def error_messages
-    card.errors.map do |error|
-      if error.attribute == :abort
-        simple_error_message error.message
-      else
-        standard_error_message error
-      end
-    end
-  end
-
-  # for override
-  def simple_error_message message
-    message
-  end
-
-  # for override
-  def standard_error_message error
-    "#{error.attribute.to_s.upcase}: #{error.message}"
-  end
-
-  def unsupported_view_error_message view
-    tr(:unsupported_view, view: view, cardname: card.name)
-  end
-end
-
-module JsonFormat; module_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-format/set/all/error.rb ~~

data/tmpsets/set/mod008-card-mod-format/all/export.rb

@@ -1,77 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Export)
-#
-module Export;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-format/set/all/export.rb"; end
-module JsonFormat; module_parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
-  # returns an array of Hashes (each in export_item view)
-  view :export, cache: :never do
-    exporting_uniques do
-      Array.wrap(render_export_item).concat(export_items_in_view(:export)).flatten
-    end
-  end
-
-  def max_export_depth
-    Env.params[:max_export_depth].present? ? Env.params[:max_export_depth].to_i : 2
-  end
-
-  # returns an array of Hashes (each in export_item view)
-  view :export_items, cache: :never do
-    exporting_uniques do
-      export_items_in_view(:export).flatten
-    end
-  end
-
-  # returns Hash with the essentials needed to import a card into a new database
-  view :export_item do
-    item = { name: card.name, type: card.type_name, content: card.content }
-    item[:codename] = card.codename if card.codename
-    track_exporting card
-    item
-  end
-
-  def export_items_in_view view
-    within_max_depth do
-      valid_items_for_export.map do |item|
-        nest item, view: view
-      end
-    end
-  end
-
-  def track_exporting card
-    return unless @exported_keys
-    @exported_keys << card.key
-  end
-
-  def exporting_uniques
-    @exported_keys ||= inherit(:exported_keys) || ::Set.new
-    yield
-  end
-
-  # prevent recursion
-  def within_max_depth
-    @export_depth ||= inherit(:export_depth).to_i + 1
-    @export_depth > max_export_depth ? [] : yield
-  end
-
-  def items_for_export
-    nest_chunks.map do |chunk|
-      next if chunk.try :main?
-      chunk.referee_card
-    end.compact
-  end
-
-  def valid_items_for_export
-    items_for_export.flatten.reject(&:blank?).uniq.find_all do |card|
-      valid_export_card? card
-    end
-  end
-
-  def valid_export_card? ecard
-    ecard.real? && !@exported_keys.include?(ecard.key)
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-format/set/all/export.rb ~~

data/tmpsets/set/mod008-card-mod-format/all/file.rb

@@ -1,18 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (File)
-#
-module File;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-format/set/all/file.rb"; end
-module FileFormat; module_parent.send :register_set_format, Card::Format::FileFormat, self; extend Card::Set::AbstractFormat
-  view :core do
-    "File rendering of this card not yet supported"
-  end
-
-  view :style do
-    nil
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-format/set/all/file.rb ~~

data/tmpsets/set/mod008-card-mod-format/all/frame.rb

@@ -1,62 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Frame)
-#
-module Frame;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-format/set/all/frame.rb"; end
-module HtmlFormat; module_parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  view :flash, cache: :never, unknown: true, perms: :none do
-    flash_notice = params[:flash] || Env.success.flash
-    return "" unless flash_notice.present? && focal?
-
-    Array(flash_notice).join "\n"
-  end
-
-  def frame &block
-    standard_frame(&block)
-  end
-
-  def standard_frame slot=true
-    with_frame slot do
-      wrap_body { yield } if block_given?
-    end
-  end
-
-  def with_frame slot=true, header=frame_header, slot_opts={}
-    voo.hide :help
-    add_name_context
-    wrap slot, slot_opts do
-      panel do
-        [header, frame_help, render_flash, (yield if block_given?)]
-      end
-    end
-  end
-
-  def frame_header
-    _render_header
-  end
-
-  def frame_help
-    with_class_up "help-text", "alert alert-info" do
-      _render :help
-    end
-  end
-
-  def frame_and_form action, form_opts={}
-    form_opts ||= {}
-    frame do
-      card_form action, form_opts do
-        yield
-      end
-    end
-  end
-
-  def panel
-    wrap_with :div, class: classy("d0-card-frame") do
-      yield
-    end
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-format/set/all/frame.rb ~~

data/tmpsets/set/mod008-card-mod-format/all/haml.rb

@@ -1,84 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Haml)
-#
-module Haml;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-format/set/all/haml.rb"; end
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  include Card::Set::Format::HamlPaths
-
-  define_method :the_scope do
-    set_scope
-  end
-
-  define_method :haml_scope do
-    set_scope
-  end
-
-  # Renders haml templates. The haml template can be passed as string or
-  # block or a symbol that refers to a view template.
-  # @param args [Hash, String, Symbol]
-  #   If a symbol is given then a template is expected in the corresponding view
-  #   directory.
-  # @return [String] rendered haml as HTML
-  # @example render a view template
-  #   # view/type/basic/my_template.haml:
-  #   %p
-  #     Hi
-  #     = name
-  #
-  #   # set/type/basic.rb:
-  #   view :my_view do
-  #     haml :my_template, name: "Joe:  # => "<p>Hi Joe<p/>"
-  #   end
-  # @example use a block to pass haml
-  #   haml name: "Joe" do
-  #     <<-HAML.strip_heredoc
-  #       %p
-  #         Hi
-  #         = name
-  #     HAML
-  #   # => <p>Hi Joe</p>
-  # @example create a slot in haml code
-  #   - haml_wrap do
-  #     %p
-  #       some haml
-
-  def haml *args, &block
-    if args.first.is_a? Symbol
-      process_haml_template(*args)
-    else
-      process_haml(*args, &block)
-    end
-  end
-
-  def haml_partial partial, locals={}
-    locals[:template_path] ||= @template_path
-    process_haml_template "_#{partial}".to_sym, locals
-  end
-
-  private
-
-  def process_haml *args
-    args.unshift yield if block_given?
-    haml_to_html(*args)
-  end
-
-  def process_haml_template template_name, *args
-    locals = args.first || {}
-    path = identify_template_path template_name, locals
-    with_template_path path do
-      haml_to_html ::File.read(path), *args
-    end
-    # rescue => e
-    #   raise Card::Error, "HAML error #{template_name}: #{e.message}\n#{e.backtrace}"
-  end
-
-  def identify_template_path view, locals={}
-    base_path = locals.delete(:template_path) || caller_locations[2].path
-    haml_template_path view, base_path
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-format/set/all/haml.rb ~~

data/tmpsets/set/mod008-card-mod-format/all/head.rb

@@ -1,157 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Head)
-#
-module Head;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card-mod-format/set/all/head.rb"; end
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  view :page_title, unknown: true, perms: :none do
-    title_parts = [Card::Rule.global_setting(:title)]
-    title_parts.unshift safe_name if card.name.present?
-    title_parts.join " - "
-  end
-end
-
-module HtmlFormat; module_parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
-  # add tuples containing a
-  #  - the codename of a card with javascript config (usually in json format)
-  #  - the name of a javascript method that handles the config
-  basket :mod_js_config
-
-  view :head, unknown: true, perms: :none do
-    views_in_head.map { |viewname| render viewname }.flatten.compact.join "\n"
-  end
-
-  def views_in_head
-    %i[meta_tags page_title_tag favicon_tag head_stylesheet
-       decko_script_variables head_javascript html5shiv_tag
-       script_config_and_initiation
-       universal_edit_button rss_links]
-  end
-
-  # FIXME: tags not working with `template: :haml`
-  view :meta_tags, unknown: true, perms: :none do
-    haml :meta_tags
-  end
-
-  view :html5shiv_tag, unknown: true, perms: :none do
-    nest :script_html5shiv_printshiv, view: :script_tag
-  end
-
-  view :page_title_tag, unknown: true, perms: :none do
-    content_tag(:title) { render :page_title }
-  end
-
-  view :favicon_tag, unknown: true, perms: :none do
-    nest :favicon, view: :link_tag
-  end
-
-  view :universal_edit_button, unknown: true, denial: :blank, perms: :update do
-    return if card.new?
-    tag "link", rel: "alternate", type: "application/x-wiki",
-                title: "Edit this page!", href: path(view: :edit)
-  end
-
-  # these should render a view of the rule card
-  # it would then be safe to cache if combined with param handling
-  # (but note that machine clearing would need to reset card cache...)
-  view :head_stylesheet, unknown: true, cache: :never, perms: :none do
-    return unless (href = head_stylesheet_path)
-    tag "link", href: href, media: "all", rel: "stylesheet", type: "text/css"
-  end
-
-  view :head_javascript, unknown: true, cache: :never, perms: :none do
-    Array.wrap(head_javascript_paths).map do |path|
-      javascript_include_tag path
-    end
-  end
-
-  view :decko_script_variables, unknown: true, cache: :never, perms: :none do
-    string = ""
-    decko_script_variables.each do |k, v|
-      string += "#{k}=#{script_variable_to_js v};\n"
-    end
-    javascript_tag { string }
-  end
-
-  def decko_script_variables
-    {
-      "window.decko": { rootUrl: card_url("") },
-      "decko.doubleClick": Card.config.double_click,
-      "decko.cssPath": head_stylesheet_path,
-      "decko.currentUserId": (Auth.current_id if Auth.signed_in?)
-
-    }
-  end
-
-  def script_variable_to_js value
-    if value.is_a? Hash
-      string = "{"
-      value.each { |k, v| string += "#{k}:#{script_variable_to_js v}" }
-      string + "}"
-    else
-      "'#{value}'"
-    end
-  end
-
-  def param_or_rule_card setting
-    if params[setting]
-      Card[params[setting]]
-    else
-      root.card.rule_card setting
-    end
-  end
-
-  def debug_or_machine_path setting, &block
-    return unless (asset_card = param_or_rule_card setting)
-    debug_path(setting, asset_card, &block) || asset_card.machine_output_url
-  end
-
-  def debug_path setting, asset_card
-    return unless params[:debug] == setting.to_s
-    yield asset_card
-  end
-
-  def head_stylesheet_path
-    debug_or_machine_path :style do |style_card|
-      path mark: style_card.name, item: :import, format: :css
-    end
-  end
-
-  def head_javascript_paths
-    debug_or_machine_path :script do |script_card|
-      script_card.item_cards.map do |script|
-        script.format(:js).render :source
-      end
-    end
-  end
-
-  view :script_config_and_initiation, unknown: true, perms: :none do
-    javascript_tag do
-      (mod_js_configs << trigger_slot_ready).join "\n\n"
-    end
-  end
-
-  def mod_js_configs
-    mod_js_config.map do |codename, js_decko_function|
-      config_json = escape_javascript Card::Rule.global_setting(codename)
-      "decko.#{js_decko_function}('#{config_json}')"
-    end
-  end
-
-  def trigger_slot_ready
-    "$('document').ready(function() { $('.card-slot').trigger('slotReady'); })"
-  end
-
-  # TODO: move to rss mod
-  view :rss_links, unknown: true, perms: :none do
-    render :rss_link_tag if rss_link?
-  end
-
-  def rss_link?
-    Card.config.rss_enabled && respond_to?(:rss_link_tag)
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card-mod-format/set/all/head.rb ~~