card-mod-collection 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cabe6e7e22075e4414381fa6929b7c012c03049d1eb477eca3bda54eb0cf4508
+  data.tar.gz: 815252c283d17851de677f1692b98733524387b2f8fc07e3fa3decc24480aaa7
+SHA512:
+  metadata.gz: dbf957e00b6dd53cef2cd622497a84fad0ad24f1bde19f77cb7c1dfc79df8a3c890d401e59ce422ff8c5dd50e926177314f74f3441d27c13182a33a8104f70c4
+  data.tar.gz: 8978ebdad15565e224b64de457b6c5dafb5bc7172bcaec56412bbe64cb4adf7d4593e97eff60b49b131a301cf53232210dccbf0749dbb9c16956bebce393e82a

data/set/abstract/items.rb

@@ -0,0 +1,202 @@
+# ~~~~~~~~~~~~ READING ITEMS ~~~~~~~~~~~~
+
+# While each of the three main methods for returning lists of items can handle arguments,
+# they are most commonly used without them.
+
+# @return [Array] list of Card::Name objects
+# @param args [Hash]
+# @option args [String] :content override card content
+# @option args [String, Card::Name, Symbol] :context name in whose context relative items
+#         will be interpreted. For example. +A in context of B is interpreted as B+A
+#         context defaults to pointer card's name. If value is `:raw`, then name is not
+#         contextualized
+# @option args [String, Integer] :limit max number of cards to return
+# @option args [String, Integer] :offset begin after the offset-th item
+def item_names args={}
+  context = args[:context]
+  item_strings(args).map do |item|
+    clean_item_name item, context
+  end.compact
+end
+
+def first_name args={}
+  item_names(args).first
+end
+
+def first_card args={}
+  return unless (name = first_name)
+  fetch_item_card name, args
+end
+
+def first_code
+  first_card&.codename
+end
+
+def first_id
+  first_card&.id
+end
+
+# @return [Array] list of integers (card ids of items)
+# @param args [Hash] see #item_names
+def item_ids args={}
+  item_names(args).map { |name| Card.fetch_id name }.compact
+end
+
+# @return [Array] list of Card objects
+# @param args [Hash] see #item_names for additional options
+# @option args [String] :complete keyword to use in searching among items
+# @option args [True/False] :known_only if true, return only known cards
+# @option args [String] :type name of type to be used for unknown cards
+def item_cards args={}
+  return item_cards_search(args) if args[:complete]
+  return known_item_cards(args) if args[:known_only]
+  all_item_cards args
+end
+
+# #item_name, #item_id, and #item_card each return a single item, rather than an array.
+%i[name id card].each do |obj|
+  define_method "item_#{obj}" do |args={}|
+    send("item_#{obj}s", args.merge(limit: 1)).first
+  end
+end
+
+# for override, eg by json
+def item_value item_name
+  item_name
+end
+
+# ~~~~~~~~~~~~ ALTERING ITEMS ~~~~~~~~~~~~
+
+# set card content based on array and save card
+# @param array [Array] list of strings/names (Cardish)
+def items= array
+  items_to_content array
+  save!
+end
+
+# append item to list (does not save)
+# @param cardish [Cardish]
+def << cardish
+  add_item cardish
+end
+
+# append item to list (does not save)
+# @param cardish [String, Card::Name] item name
+# @param allow_duplicates [True/False] permit duplicate items (default is False)
+def add_item cardish, allow_duplicates=false
+  return if !allow_duplicates && include_item?(cardish)
+
+  items = item_strings << cardish
+  items_to_content items
+end
+
+# append item to list and save card
+# @param name [String, Card::Name] item name
+def add_item! name
+  add_item(name) && save!
+end
+
+# remove item from list
+# @param cardish [String, Card::Name] item to drop
+def drop_item cardish
+  drop_item_name = Card::Name[cardish]
+  items_to_content(item_names.reject { |item_name| item_name == drop_item_name })
+end
+
+# remove item from list and save card
+# @param cardish [String, Card::Name] item to drop
+def drop_item! cardish
+  drop_item cardish
+  save!
+end
+
+# insert item into list at specified location
+# @param index [Integer] Array index in which to insert item (0 is first)
+# @param name [String, Card::Name] item name
+def insert_item index, name
+  new_names = item_names
+  new_names.delete name
+  new_names.insert index, name
+  items_to_content new_names
+end
+
+# insert item into list at specified location and save
+# @param index [Integer] Array index in which to insert item (0 is first)
+# @param name [String, Card::Name] item name
+def insert_item! index, name
+  insert_item index, name
+  save!
+end
+
+# ~~~~~~~~~~~~ READING ITEM HELPERS ~~~~~~~~~~~~
+
+# Warning: the following methods, while available for use, may be subject to change
+
+# #item_cards helpers
+
+def item_cards_search query
+  Card::Query.run query.reverse_merge(referred_to_by: name, limit: 0)
+end
+
+def known_item_cards args={}
+  item_names(args).map { |name| Card.fetch name }.compact
+end
+
+def all_item_cards args={}
+  names = args[:item_names] || item_names(args)
+  names.map { |name| fetch_item_card name, args }
+end
+
+# TODO: support type_code and type_id. (currently type)
+# uses name, because its most common use is from CQL
+def item_type
+  opt = options_rule_card
+  # FIXME: need better recursion prevention
+  return if !opt || opt == self
+  opt.item_type
+end
+
+def item_strings args={}
+  items = raw_item_strings(args[:content] || content)
+  return items unless args.present?
+
+  filtered_items items, args.slice(:limit, :offset)
+end
+
+def raw_item_strings content
+  content.to_s.split(/\n+/).map { |i| strip_item i }
+end
+
+private
+
+def filtered_items items, limit: 0, offset: 0
+  limit = limit.to_i
+  offset = offset.to_i
+  return items unless limit.positive? || offset.positive?
+
+  items[offset, (limit.zero? ? items.size : limit)] || []
+end
+
+def fetch_item_card name, args={}
+  Card.fetch name, new: new_unknown_item_args(args)
+end
+
+def new_unknown_item_args args
+  itype = args[:type] || item_type
+  itype ? { type: itype } : {}
+end
+
+def clean_item_name item, context
+  item = item.to_name
+  return item if context == :raw
+  context ||= context_card.name
+  item.absolute_name context
+rescue Card::Error::NotFound
+  # eg for invalid ids or codenames
+  # "Invalid Item: #{item}".to_name
+  nil
+end
+
+def strip_item item
+  item.gsub(/\[\[|\]\]/, "").strip
+end

data/set/abstract/paging.rb

@@ -0,0 +1,64 @@
+MAX_ANONYMOUS_SEARCH_PARAM = 1000
+
+format do
+  def limit
+    @limit ||= contextual_param(:limit) || default_limit
+  end
+
+  def offset
+    @offset ||= contextual_param(:offset) || 0
+  end
+
+  def search_with_params
+    @search_with_params ||= card.item_names
+  end
+
+  def count_with_params
+    @count_with_params ||= card.item_names.count
+  end
+
+  def total_pages
+    return 1 if limit.zero?
+    ((count_with_params - 1) / limit).to_i
+  end
+
+  def current_page
+    (offset / limit).to_i
+  end
+
+  # for override
+  def extra_paging_path_args
+    {}
+  end
+
+  private
+
+  def contextual_param param
+    env_search_param(param) || voo_search_param(param)
+  end
+
+  def env_search_param param
+    enforcing_legal_limit param do
+      val = Env.params[param]
+      val.to_i if focal? && val.present?
+    end
+  end
+
+  def enforcing_legal_limit param
+    yield.tap do |val|
+      enforce_legal_limit! val if param == :limit
+    end
+  end
+
+  def enforce_legal_limit! val
+    return if Card::Auth.signed_in? || !val || val <= MAX_ANONYMOUS_SEARCH_PARAM
+
+    raise Card::Error::PermissionDenied,
+          "limit parameter exceeds maximum for anonymous users " \
+          "(#{MAX_ANONYMOUS_SEARCH_PARAM})"
+  end
+
+  def voo_search_param param
+    voo&.cql&.dig(param)&.to_i
+  end
+end

data/set/abstract/paging/paging_links.rb

@@ -0,0 +1,90 @@
+#! no set module
+
+# render paging links
+class PagingLinks
+  def initialize total_pages, current_page
+    @total = total_pages
+    @current = current_page
+  end
+
+  # @param window [integer] number of page links shown left and right
+  #   of the current page
+  # @example: current page = 5, window = 2
+  #   |<<|1|...|3|4|[5]|6|7|...|10|>>|
+  # @yield [text, page, status, options] block to build single paging link
+  # @yieldparam status [Symbol] :active (for current page) or :disabled
+  # @yieldparam page [Integer] page number, first page is 0
+  # @return [Array<String>]
+  def build window=2, &block
+    @render_item = block
+    links window
+  end
+
+  private
+
+  def links window
+    @window_start = [@current - window, 0].max
+    @window_end = [@current + window, @total].min
+    left_part + window_part + right_part
+  end
+
+  # the links around the current page
+  def window_part
+    (@window_start..@window_end).map do |page|
+      direct_page_link page
+    end.compact
+  end
+
+  def left_part
+    [
+      previous_page_link,
+      (direct_page_link 0 if @window_start.positive?),
+      (ellipse if @window_start > 1)
+    ].compact
+  end
+
+  def right_part
+    [
+      (ellipse if @total > @window_end + 1),
+      (direct_page_link @total if @total > @window_end),
+      next_page_link
+    ].compact
+  end
+
+  def previous_page_link
+    paging_item '<span aria-hidden="true">&laquo;</span>', previous_page,
+                "aria-label" => "Previous", status: :previous
+  end
+
+  def next_page_link
+    paging_item '<span aria-hidden="true">&raquo;</span>', next_page,
+                "aria-label" => "Next", status: :next
+  end
+
+  def direct_page_link page
+    return unless page >= 0 && page <= @total
+    paging_item page + 1, page
+  end
+
+  def ellipse
+    paging_item "<span>...</span>", nil, status: :ellipses
+  end
+
+  def paging_item text, page, options={}
+    status =
+      if page == @current
+        :current
+      else
+        options.delete :status
+      end
+    @render_item.call text, page, status, options
+  end
+
+  def previous_page
+    @current.positive? ? @current - 1 : false
+  end
+
+  def next_page
+    @current < @total ? @current + 1 : false
+  end
+end

data/set/abstract/paging/paging_views.rb

@@ -0,0 +1,111 @@
+format :html do
+  PAGE_LI_CLASS = { ellipses: "disabled", current: "active" }.freeze
+
+  def with_paging path_args={}
+    with_paging_path_args path_args do
+      output [yield(@paging_path_args), _render_paging]
+    end
+  end
+
+  view :paging, cache: :never do
+    return "" unless paging_needed?
+    <<-HTML
+      <nav>
+        <ul class="pagination paging">
+          #{paging_links.join}
+        </ul>
+      </nav>
+    HTML
+  end
+
+  def paging_links
+    PagingLinks.new(total_pages, current_page).build do |text, page, status, options|
+      page_link_li text, page, status, options
+    end
+  end
+
+  # First page is 0 (not 1)
+  def page_link_li text, page, status, options={}
+    wrap_with :li, class: page_link_li_class(status) do
+      page_link text, page, options
+    end
+  end
+
+  def page_link_li_class status
+    ["page-item", PAGE_LI_CLASS[status]].compact.join " "
+  end
+
+  def page_link text, page, options
+    return content_tag(:div, text.html_safe, class: "page-link") unless page
+
+    options.merge! class: "card-paging-link slotter page-link",
+                   remote: true,
+                   path: page_link_path_args(page)
+    link_to raw(text), options
+  end
+
+  def with_paging_path_args args
+    tmp = @paging_path_args
+    @paging_path_args = paging_path_args args
+    yield
+  ensure
+    @paging_path_args = tmp
+  end
+
+  def paging_path_args local_args={}
+    @paging_path_args ||= {}
+    @paging_path_args.reverse_merge!(limit: limit, offset: offset)
+    @paging_path_args.merge! extra_paging_path_args
+    @paging_path_args.merge local_args
+  end
+
+  def page_link_path_args page
+    paging_path_args.merge offset: page * limit
+  end
+
+  def paging_needed?
+    return false if limit < 1
+    return false if fewer_results_than_limit? # avoid extra count search
+
+    # count search result instead
+    limit < count_with_params
+  end
+
+  # clear we don't need paging even before running count query
+  def fewer_results_than_limit?
+    return false unless offset.zero?
+
+    limit > offset + search_with_params.length
+  end
+end
+
+format :json do
+  def page_link_path_args page
+    {
+      limit: limit,
+      offset: page * limit,
+      item: default_item_view, # hack. need standard voo handling
+      format: :json
+    }.merge extra_paging_path_args
+  end
+
+  view :paging_urls, cache: :never do
+    return {} unless total_pages > 1
+
+    { paging: paging_urls_hash }
+  end
+
+  def paging_urls_hash
+    hash = {}
+    PagingLinks.new(total_pages, current_page).build do |_text, page, status, _options|
+      add_paging_url hash, page, status
+    end
+    hash
+  end
+
+  def add_paging_url hash, page, status
+    return unless page && status.in?(%i[next previous])
+
+    hash[status] = path page_link_path_args(page)
+  end
+end

data/set/all/extended.rb

@@ -0,0 +1,49 @@
+
+def extended_item_cards context=nil
+  items = item_cards limit: "", context: (context || self).name
+  list = []
+  book = ::Set.new # avoid loops
+  extend_item_list items, list, book until items.empty?
+  list
+end
+
+def extended_item_contents context=nil
+  extended_item_cards(context).map(&:item_names).flatten
+end
+
+format do
+  delegate :extended_item_contents, to: :card
+end
+
+private
+
+def extend_item_list items, list, book
+  item = items.shift
+  return if already_extended? item, book
+  if item.collection?
+    # keep items in order
+    items.unshift(*item.item_cards)
+  else  # no further level of items
+    list << item
+  end
+end
+
+def already_extended? item, book
+  return true if book.include? item
+  book << item
+  false
+end
+
+# def extended_list context=nil
+#   context = (context ? context.name : name)
+#   args = { limit: "" }
+#   item_cards(args.merge(context: context)).map do |x|
+#     x.item_cards(args)
+#   end.flatten.map do |x|
+#     x.item_cards(args)
+#   end.flatten.map do |y|
+#     y.item_names(args)
+#   end.flatten
+#   # this could go on and on.  more elegant to recurse until you don't have
+#   # a collection
+# end

data/set/all/item.rb

@@ -0,0 +1,130 @@
+def item_names _args={}
+  format._render_raw.split(/[,\n]/)
+end
+
+def item_cards _args={} # FIXME: this is inconsistent with item_names
+  [self]
+end
+
+def item_type
+  nil
+end
+
+def item_keys args={}
+  item_names(args).map do |item|
+    item.to_name.key
+  end
+end
+
+def item_count args={}
+  item_names(args).size
+end
+
+def items_to_content array
+  items = array.map { |i| standardize_item i }.reject(&:blank?)
+  self.content = items.to_pointer_content
+end
+
+def standardize_item item
+  Card::Name[item]
+end
+
+def include_item? item
+  item_names.include? Card::Name[item]
+end
+
+def add_item item
+  return if include_item? item
+  items_to_content(items_strings << item)
+end
+
+def drop_item item
+  item = Card::Name[item]
+  return unless include_item? item
+  items_to_content(item_names.reject { |i| i == item })
+end
+
+def insert_item index, name
+  new_names = item_names
+  new_names.delete name
+  new_names.insert index, name
+  items_to_content new_names
+end
+
+def replace_item old, new
+  return unless include_item? old
+  drop_item old
+  add_item new
+end
+
+# I think the following should work as add_item...
+#
+def add_id id
+  add_item "~#{id}"
+end
+
+def drop_id id
+  drop_item "~#{id}"
+end
+
+def insert_id index, id
+  insert_item index, "~#{id}"
+end
+
+format do
+  def item_links _args={}
+    raw(render_core).split(/[,\n]/)
+  end
+
+  def nest_item cardish, options={}, &block
+    options = item_view_options options
+    options[:nest_name] = Card::Name[cardish].s
+    nest cardish, options, &block
+  end
+
+  def implicit_item_view
+    view = voo_items_view || default_item_view
+    Card::View.normalize view
+  end
+
+  def voo_items_view
+    return unless voo && (items = voo.items)
+    items[:view]
+  end
+
+  def default_item_view
+    :name
+  end
+
+  def item_view_options new_options={}
+    options = (voo.items || {}).clone
+    options = options.merge new_options
+    options[:view] ||= implicit_item_view
+    determine_item_view_options_type options
+    options
+  end
+
+  def determine_item_view_options_type options
+    return if options[:type]
+    type_from_rule = card.item_type
+    options[:type] = type_from_rule if type_from_rule
+  end
+
+  def listing listing_cards, item_args={}
+    listing_cards.map do |item_card|
+      nest_item item_card, item_args do |rendered, item_view|
+        wrap_item rendered, item_view
+      end
+    end
+  end
+
+  def wrap_item item, _args={}
+    item # no wrap in base
+  end
+end
+
+format :html do
+  def wrap_item rendered, item_view
+    %(<div class="item-#{item_view}">#{rendered}</div>)
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-collection
+version: !ruby/object:Gem::Version
+  version: 0.11.0
+platform: ruby
+authors:
+- Ethan McCutchen
+- Philipp Kühl
+- Gerry Gleason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- set/abstract/items.rb
+- set/abstract/paging.rb
+- set/abstract/paging/paging_links.rb
+- set/abstract/paging/paging_views.rb
+- set/all/extended.rb
+- set/all/item.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: collection
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: collection (list and search)
+test_files: []