card 1.99.6 → 1.100.0

data/tmpsets/set/mod020-media/abstract/media.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (Media)
+#
+module Media;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/media/set/abstract/media.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def image_card
+    @image_card ||= card.fetch(:image, new: {})
+  end
+
+  def text_with_image opts={}
+    class_up "media-left", "m-2"
+    @image_card = Card.cardish(opts[:image]) if opts[:image]
+    haml :media_snippet, normalized_text_with_image_opts(opts)
+  end
+
+  private
+
+  def normalized_text_with_image_opts opts
+    opts.reverse_merge! title: _render_title, text: "", size: voo.size, media_opts: {}
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/media/set/abstract/media.rb ~~

data/tmpsets/set/mod020-media/self/style_media.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Self
+# Set: The card "StyleMedia"
+#
+module StyleMedia;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/media/set/self/style_media.rb"; end
+include_set Abstract::CodeFile
+Self::StyleMods.add_item :style_media
+
+def source_files
+  scss_files [:image_box]
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/media/set/self/style_media.rb ~~

data/tmpsets/set/mod020-media/type/image.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Type
+# Set: All "Image" cards
+#
+module Image;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/media/set/type/image.rb"; end
+IMAGE_BOX_SIZE_MAP = {
+  icon: :icon, small: :small, medium: :small, large: :medium, xlarge: :medium
+}.freeze
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :boxed, unknown: true do
+    image_box { |size| render_core size: size }
+  end
+
+  view :boxed_link, unknown: true do
+    image_box { |size| link_to_card image_box_link_target, render_core(size: size) }
+  end
+
+  def image_box
+    voo.size ||= :medium
+    wrap_with :div, title: image_box_title, class: "image-box #{voo.size}" do
+      yield image_box_size
+    end
+  end
+
+  ## METHODS FOR OVERRIDE
+
+  def image_box_size
+    IMAGE_BOX_SIZE_MAP[voo.size.to_sym] || :medium
+  end
+
+  def image_box_card_name
+    card.name.junction? ? card.name.left : card.name
+  end
+
+  def image_box_link_target
+    image_box_card_name
+  end
+
+  def image_box_title
+    voo.title || image_box_card_name
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/media/set/type/image.rb ~~

data/tmpsets/set/mod021-search/abstract/00_filter_helper.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (FilterHelper)
+#
+# TODO: move sort/filter handling out of card and into base format
+module FilterHelper;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/00_filter_helper.rb"; end
+# sorting and filtering is about viewing the data, not altering the data itself.
+
+def sort_hash
+  sort_param.present? ? { sort: sort_param } : {}
+end
+
+def filter_param field
+  filter_hash[field.to_sym]
+end
+
+# FIXME: it is inconsistent that #sort_hash has :sort as the key, but
+# #filter_hash is the _value_ of the hash with :filter as the key.
+def filter_hash
+  @filter_hash ||=
+    Env.params[:filter].present? ? Env.hash(Env.params[:filter]) : default_filter_hash
+end
+
+def sort_param
+  @sort_param ||= safe_sql_param :sort
+end
+
+def safe_sql_param key
+  param = Env.params[key]
+  param.blank? ? nil : Card::Query.safe_sql(param)
+end
+
+def filter_keys_with_values
+  filter_keys.map do |key|
+    values = filter_param(key)
+    values.present? ? [key, values] : next
+  end.compact
+end
+
+# initial values for filtered search
+def default_filter_hash
+  {}
+end
+
+def offset
+  param_to_i :offset, 0
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  delegate :filter_hash, :sort_hash, :filter_param, :sort_param,
+           :all_filter_keys, to: :card
+
+  def extra_paging_path_args
+    super.merge filter_and_sort_hash
+  end
+
+  def filter_and_sort_hash
+    sort_hash.merge filter: filter_hash
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/00_filter_helper.rb ~~

data/tmpsets/set/mod021-search/abstract/02_search_params.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (SearchParams)
+#
+module SearchParams;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/02_search_params.rb"; end
+include_set Abstract::PagingParams
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def offset
+    search_params[:offset] || 0
+  end
+
+  def search_params
+    @search_params ||= default_search_params
+  end
+
+  # used for override
+  def default_search_params
+    if (qparams = query_params)
+      paging_params.merge vars: qparams
+    else
+      paging_params
+    end
+  end
+
+  def paging_params
+    { limit: limit_param, offset: offset_param }
+  end
+
+  def query_params
+    return nil unless (vars = params[:query])
+
+    Env.hash vars
+  end
+
+  def default_limit
+    100
+  end
+
+  def extra_paging_path_args
+    return {} unless (vars = query_params)
+
+    { query: vars }
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def default_limit
+    Cardio.config.paging_limit || 20
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  def default_limit
+    20
+  end
+end
+
+module RssFormat; parent.send :register_set_format, Card::Format::RssFormat, self; extend Card::Set::AbstractFormat
+  def default_limit
+    25
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/02_search_params.rb ~~

data/tmpsets/set/mod021-search/abstract/03_filter.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (Filter)
+#
+module Filter;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter.rb"; end
+include_set Abstract::Utility
+
+def filter_class
+  Card::FilterQuery
+end
+
+def filter_keys
+  [:name]
+end
+
+def filter_keys_from_params
+  filter_hash.keys.map(&:to_sym) - [:not_ids]
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def sort_options
+    { "Alphabetical": :name, "Recently Added": :create }
+  end
+
+  view :filtered_content, template: :haml, wrap: :slot
+
+  view :selectable_filtered_content, template: :haml, cache: :never
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter.rb ~~

data/tmpsets/set/mod021-search/abstract/03_filter/filter_form.rb

@@ -0,0 +1,107 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Filter;
+# Set: Abstract (Filter, FilterForm)
+#
+module FilterForm;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter/filter_form.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  # sort and filter ui
+  view :filter_form, cache: :never do
+    filter_fields slot_selector: "._filter-result-slot",
+                  sort_field: _render(:sort_formgroup)
+  end
+
+  view :quick_filters, cache: :never do
+    return "" unless quick_filter_list.present?
+
+    haml :quick_filters, filter_list: normalized_quick_filter_list
+  end
+
+  def normalized_quick_filter_list
+    quick_filter_list.map do |hash|
+      hash = hash.clone
+      filter_key = hash.keys.first
+      {
+        text: (hash.delete(:text) || hash[filter_key]),
+        icon: (hash.delete(:icon) || mapped_icon_tag(filter_key)),
+        # FIXME: mapped_icon_tag is a wikirate concept
+        class:  css_classes(hash.delete(:class),
+                            "_filter-link quick-filter-by-#{filter_key}"),
+        filter: JSON(hash[:filter] || hash)
+      }
+    end
+  end
+
+  # for override
+  def quick_filter_list
+    []
+  end
+
+  # for override
+  def custom_quick_filters
+    ""
+  end
+
+  # @param data [Hash] the filter categories. The hash needs for every category
+  #   a hash with a label and a input_field entry.
+  def filter_form data={}, sort_input_field=nil, form_args={}
+    haml :filter_form, categories: data,
+                       sort_input_field: sort_input_field,
+                       form_args: form_args
+  end
+
+  def filter_fields slot_selector: nil, sort_field: nil
+    form_args = { action: filter_action_path, class: "slotter" }
+    form_args["data-slot-selector"] = slot_selector if slot_selector
+    filter_form filter_form_data, sort_field, form_args
+  end
+
+  def filter_form_data
+    all_filter_keys.each_with_object({}) do |cat, h|
+      h[cat] = { label: filter_label(cat),
+                 input_field: _render("filter_#{cat}_formgroup"),
+                 active: active_filter?(cat),
+                 default: default_filter?(cat) }
+    end
+  end
+
+  def active_filter? field
+    if card.filter_keys_from_params.present?
+      filter_hash.key? field
+    else
+      default_filter? field
+    end
+  end
+
+  def default_filter? field
+    card.default_filter_hash.key? field
+  end
+
+  def filter_label field
+    # return "Keyword" if field.to_sym == :name
+    #
+    filter_label_from_method(field) || filter_label_from_name(field)
+  end
+
+  def filter_label_from_method field
+    try "#{field}_filter_label"
+  end
+
+  def filter_label_from_name field
+    Card.fetch_name(field) { field.to_s.titleize }
+  end
+
+  def filter_action_path
+    path
+  end
+
+  view :sort_formgroup, cache: :never do
+    select_tag "sort",
+               options_for_select(sort_options, card.current_sort),
+               class: "pointer-select _filter-sort form-control",
+               "data-minimum-results-for-search": "Infinity"
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter/filter_form.rb ~~

data/tmpsets/set/mod021-search/abstract/03_filter/form_helper.rb

@@ -0,0 +1,114 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Filter;
+# Set: Abstract (Filter, FormHelper)
+#
+module FormHelper;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter/form_helper.rb"; end
+include_set Abstract::FilterHelper
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :filter_name_formgroup, cache: :never do
+    text_filter :name
+  end
+
+  def select_filter field, default=nil, options=nil
+    options ||= filter_options field
+    options.unshift(["--", ""]) unless default
+    select_filter_tag field, default, options
+  end
+
+  def multiselect_filter field, default=nil, options=nil
+    options ||= filter_options field
+    multiselect_filter_tag field, default, options
+  end
+
+  def text_filter field, default=nil, opts={}
+    value = filter_param(field) || default
+    text_filter_with_name_and_value filter_name(field), value, opts
+  end
+
+  def text_filter_with_name_and_value name, value, opts
+    opts[:class] ||= "simple-text"
+    add_class opts, "form-control"
+    text_field_tag name, value, opts
+  end
+
+  def range_filter field, default={}, opts={}
+    add_class opts, "simple-text range-filter-subfield"
+    default ||= {}
+    output [range_sign(:from),
+            sub_text_filter(field, :from, default, opts),
+            range_sign(:to),
+            sub_text_filter(field, :to, default, opts)]
+  end
+
+  def range_sign side
+    dir = side == :from ? "right" : "left"
+    wrap_with :span, class: "input-group-prepend" do
+      fa_icon("chevron-circle-#{dir}", class: "input-group-text")
+    end
+  end
+
+  def sub_text_filter field, subfield, default={}, opts={}
+    name = "filter[#{field}][#{subfield}]"
+    value = filter_hash.dig(field, subfield) || default[subfield]
+    text_filter_with_name_and_value name, value, opts
+  end
+
+  def autocomplete_filter type_code, options_card=nil
+    options_card ||= Card::Name[type_code, :type, :by_name]
+    text_filter type_code, "", class: "#{type_code}_autocomplete",
+                               "data-options-card": options_card
+  end
+
+  def multiselect_filter_tag field, default, options, html_options={}
+    html_options[:multiple] = true
+    select_filter_tag field, default, options, html_options
+  end
+
+  def select_filter_tag field, default, options, html_options={}
+    name = filter_name field, html_options[:multiple]
+    options = options_for_select options, (filter_param(field) || default)
+    normalize_select_filter_tag_html_options field, html_options
+    select_tag name, options, html_options
+  end
+
+  # alters html_options hash
+  def normalize_select_filter_tag_html_options field, html_options
+    pointer_suffix = html_options[:multiple] ? "multiselect" : "select"
+    add_class html_options, "pointer-#{pointer_suffix} filter-input #{field} " \
+                            "_filter_input_field _no-select2 form-control"
+    # _no-select2 because select is initiated after filter is opened.
+    html_options[:id] = "filter-input-#{unique_id}"
+  end
+
+  def filter_name field, multi=false
+    "filter[#{field}]#{'[]' if multi}"
+  end
+
+  def filter_options field
+    raw = send("#{field}_options")
+    raw.is_a?(Array) ? raw : option_hash_to_array(raw)
+  end
+
+  def option_hash_to_array hash
+    hash.each_with_object([]) do |(key, value), array|
+      array << [key, value.to_s]
+      array
+    end
+  end
+
+  def type_options type_codename, order="asc", max_length=nil
+    Card.cache.fetch "#{type_codename}-TYPE-OPTIONS" do
+      res = Card.search type: type_codename, return: :name, sort: "name", dir: order
+      max_length ? (res.map { |i| [trim_option(i, max_length), i] }) : res
+    end
+  end
+
+  def trim_option option, max_length
+    option.size > max_length ? "#{option[0..max_length]}..." : option
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/03_filter/form_helper.rb ~~