card 1.18.6 → 1.19.0

data/mod/standard/set/self/search.rb

@@ -0,0 +1,64 @@
+
+format :html do
+  view :title do |args|
+    vars = root.search_params[:vars]
+    if vars && vars[:keyword]
+      args[:title] = %(Search results for: <span class="search-keyword">)\
+                         "#{vars[:keyword]}</span>"
+    end
+    super args
+  end
+end
+
+format :json do
+  view :complete do
+    term = complete_term
+    exact = Card.fetch term, new: {}
+
+    {
+      search: true,
+      add: add_item(exact),
+      new: new_item_of_type(exact),
+      goto: goto_items(term, exact)
+    }
+  end
+
+  def add_item exact
+    return unless exact.new_card? &&
+                  exact.cardname.valid? &&
+                  !exact.virtual? &&
+                  exact.ok?(:create)
+    exact.name
+  end
+
+  def new_item_of_type exact
+    return unless (exact.type_id == Card::CardtypeID) &&
+                  Card.new(type_id: exact.id).ok?(:create)
+    [exact.name, exact.cardname.url_key]
+  end
+
+  def goto_items term, exact
+    goto_names = Card.search goto_wql(term), "goto items for term: #{term}"
+    goto_names.unshift exact.name if add_exact_to_goto_names? exact, goto_names
+    goto_names.map do |name|
+      [name, highlight(name, term), name.to_name.url_key]
+    end
+  end
+
+  def add_exact_to_goto_names? exact, goto_names
+    exact.known? && !goto_names.find { |n| n.to_name.key == exact.key }
+  end
+
+  def complete_term
+    term = params["_keyword"]
+    if (term =~ /^\+/) && (main = params["main"])
+      term = main + term
+    end
+    term
+  end
+
+  # hacky.  here for override
+  def goto_wql term
+    { complete: term, limit: 8, sort: "name", return: "name" }
+  end
+end

data/mod/standard/set/type/basic.rb

@@ -0,0 +1,52 @@
+format :html do
+  view :open_content do |args|
+    content = _render_core args
+    table_of_contents(content) || content
+  end
+
+  def table_of_contents content
+    return if @mode == :closed || !content.present?
+    min = card.rule(:table_of_contents).to_i
+    # warn "table_of #{name}, #{min}"
+    return unless min && min > 0
+
+    toc = []
+    dep = 1
+    content.gsub!(/<(h\d)>(.*?)<\/h\d>/i) do |match|
+      if $LAST_MATCH_INFO
+        tag, value = $LAST_MATCH_INFO[1, 2]
+        value = ActionView::Base.new.strip_tags(value).strip
+        next if value.empty?
+        item = { value: value, uri: URI.escape(value) }
+        case tag.downcase
+        when "h1"
+          item[:depth] = dep = 1
+          toc << item
+        when "h2"
+          toc << []  if dep == 1
+          item[:depth] = dep = 2
+          toc.last << item
+        end
+        %(<a name="#{item[:uri]}"></a>#{match})
+      end
+    end
+
+    if toc.flatten.length >= min
+      content.replace(
+        %( <div class="table-of-contents"> <h5>Table of Contents</h5> ) +
+          make_table_of_contents_list(toc) + "</div>" + content
+      )
+    end
+  end
+
+  def make_table_of_contents_list items
+    list = items.map do |i|
+             if i.is_a?(Array)
+               make_table_of_contents_list(i)
+             else
+               %(<li><a href="##{i[:uri]}"> #{i[:value]}</a></li>)
+             end
+           end.join("\n")
+    "<ol>" + list + "</ol>"
+  end
+end

data/mod/standard/set/type/cardtype.rb

@@ -0,0 +1,74 @@
+
+format :html do
+  view :type do |args|
+    args[:type_class] = "no-edit" if card.cards_of_type_exist?
+    super args
+  end
+
+  view :type_formgroup do |args|
+    if card.cards_of_type_exist?
+      %(
+        <div>
+          Sorry, this card must remain a Cardtype so long as there are
+          <strong>#{card.name}</strong> cards.
+        </div>
+      )
+    else
+      super args
+    end
+  end
+
+  view :add_link do |args|
+    args[:title] ||= "Add #{card.name}"
+    link_to _render_title(args), _render_add_path(args), class: args[:css_class]
+  end
+
+  view :add_button, view: :add_link
+  def default_add_button_args args
+    args[:css_class] = "btn btn-default"
+  end
+
+  view :add_url do |args|
+    card_url _render_add_path(args)
+  end
+
+  view :add_path do |args|
+    path_args = {}
+    if args[:params]
+      context = ((@parent && @parent.card) || card).name
+      Rack::Utils.parse_nested_query(args[:params]).each do |key, value|
+        value = value.to_name.to_absolute(context) if value
+        key = key.to_name.to_absolute(context)
+        path_args[key] = value
+      end
+    end
+    path_args[:action] = "new"
+    page_path card.cardname, path_args
+  end
+end
+
+include Basic
+
+def follow_label
+  default_follow_set_card.follow_label
+end
+
+def followed_by? user_id=nil
+  default_follow_set_card.all_members_followed_by? user_id
+end
+
+def default_follow_set_card
+  # FIXME: use codename
+  Card.fetch("#{name}+*type")
+end
+
+def cards_of_type_exist?
+  # FIXME: faster test than counting all of type?
+  !new_card? && Auth.as_bot { Card.count_by_wql type_id: id } > 0
+end
+
+event :check_for_cards_of_type, after: :validate_delete do
+  if cards_of_type_exist?
+    errors.add :cardtype, "can't alter this type; #{name} cards still exist"
+  end
+end

data/mod/standard/set/type/date.rb

@@ -0,0 +1,8 @@
+
+format :html do
+  # what is this for?  Can't you just use TYPE-date and editor
+  # to match this cas, no special view needed?
+  view :editor do |_args|
+    text_field :content, class: "date-editor"
+  end
+end

data/mod/standard/set/type/layout_type.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+include_set Type::Html
+
+format :html do
+  view :core do |_args|
+    with_nest_mode :template do
+      process_content ::CodeRay.scan(_render_raw, :html).div
+    end
+  end
+end

data/mod/standard/set/type/list.rb

@@ -0,0 +1,113 @@
+include_set Pointer
+
+event :validate_list_name, :validate, on: :save, changed: :name do
+  if !junction? || !right || right.type_id != CardtypeID
+    errors.add :name, "must have a cardtype name as right part"
+  end
+end
+
+event :validate_list_item_type_change, :validate,
+      on: :save, changed: :name do
+  item_cards.each do |item_card|
+    next unless item_card.type_cardname.key != item_type_name.key
+    errors.add :name,
+               "name conflicts with list items' type; " \
+               "delete content first"
+  end
+end
+
+event :validate_list_content, :validate,
+      on: :save, changed: :content do
+  item_cards.each do |item_card|
+    next unless item_card.type_cardname.key != item_type_name.key
+    errors.add :content,
+               "#{item_card.name} has wrong cardtype; " \
+               "only cards of type #{cardname.right} are allowed"
+  end
+end
+
+event :create_listed_by_cards, :prepare_to_validate,
+      on: :save, changed: :content do
+  item_names.each do |item_name|
+    listed_by_name = "#{item_name}+#{left.type_name}"
+    next if director.main_director.card.key == listed_by_name.to_name.key
+    if !Card[listed_by_name]
+      add_subcard listed_by_name, type_id: ListedByID
+    else
+      Card[listed_by_name].update_references_out
+    end
+  end
+end
+
+event :update_related_listed_by_card_on_create, :finalize,
+      on: :create do
+  update_listed_by_cache_for item_keys
+end
+
+event :update_related_listed_by_card_on_content_update, :finalize,
+      on: :update, changed: :content do
+  new_items = item_keys
+  changed_items =
+    if db_content_was
+      old_items = item_keys(content: db_content_was)
+      old_items + new_items - (old_items & new_items)
+    else
+      new_items
+    end
+  update_listed_by_cache_for changed_items
+end
+
+event :update_related_listed_by_card_on_name_and_type_changes, :finalize,
+      on: :update, changed: [:name, :type_id] do
+  update_all_items
+end
+
+event :update_related_listed_by_card_on_delete, :finalize,
+      on: :delete, when: proc { |c| c.junction? } do
+  update_listed_by_cache_for item_keys, type_key: @left_type_key
+end
+
+event :cache_type_key, :store,
+      on: :delete, when: proc { |c| c.junction? } do
+  @left_type_key = left.type_card.key
+end
+
+def update_all_items
+  current_items = item_keys
+  if db_content_was
+    old_items = item_keys(content: db_content_was)
+    update_listed_by_cache_for old_items
+  end
+  update_listed_by_cache_for current_items
+end
+
+def update_listed_by_cache_for item_keys, args={}
+  type_key = args[:type_key] || left.type_card.key
+
+  item_keys.each do |item_key|
+    key = "#{item_key}+#{type_key}"
+    next unless Card::Cache[Card::Set::Type::ListedBy].exist? key
+    if (card = Card.fetch(key))
+      card.update_cached_list
+      card.update_references_out
+    else
+      Card::Cache[Card::Set::Type::ListedBy].delete key
+    end
+  end
+end
+
+def item_type
+  cardname.right
+end
+
+def item_type_name
+  cardname.right_name
+end
+
+def item_type_card
+  cardname.right
+end
+
+def item_type_id
+  right.id
+end

data/mod/standard/set/type/listed_by.rb

@@ -0,0 +1,78 @@
+include_set Pointer
+
+event :validate_listed_by_name, :validate, on: :save, changed: :name do
+  if !junction? || !right || right.type_id != CardtypeID
+    errors.add :name, "must have a cardtype name as right part"
+  end
+end
+
+event :validate_listed_by_content, :validate,
+      on: :save, changed: :content do
+  item_cards(content: content).each do |item_card|
+    next unless item_card.type_id != right.id
+    errors.add(
+      :content,
+      "#{item_card.name} has wrong cardtype; " \
+      "only cards of type #{cardname.right} are allowed"
+    )
+  end
+end
+
+event :update_content_in_list_cards, :prepare_to_validate,
+      on: :save, changed: :content do
+  if content.present?
+    new_items = item_keys(content: content)
+    old_items = item_keys
+    removed_items = old_items - new_items
+    added_items   = new_items - old_items
+    removed_items.each do |item|
+      if (lc = list_card(item))
+        lc.drop_item cardname.left
+        subcards.add lc
+      end
+    end
+    added_items.each do |item|
+      if (lc = list_card(item))
+        lc.add_item cardname.left
+        subcards.add lc
+      else
+        subcards.add(
+          name: "#{Card[item].name}+#{left.type_name}", type: "list",
+          content: "[[#{cardname.left}]]"
+        )
+      end
+    end
+  end
+end
+
+def raw_content
+  Card::Cache[Card::Set::Type::ListedBy].fetch(key) do
+    generate_content
+  end
+end
+
+def generate_content
+  listed_by.map do |item|
+    "[[%s]]" % item.to_name.left
+  end.join "\n"
+end
+
+def listed_by
+  Card.search(
+    { type: "list", right: trunk.type_name,
+      left: { type: cardname.tag }, refer_to: cardname.trunk, return: :name
+      }, "listed_by" # better wql comment would be...better
+  )
+end
+
+def update_cached_list
+  Card::Cache[Card::Set::Type::ListedBy].write key, generate_content
+end
+
+def list_card item
+  Card.fetch item, left.type_name
+end
+
+def unfilled?
+  false
+end

data/mod/standard/set/type/number.rb

@@ -0,0 +1,18 @@
+
+view :editor do |_args|
+  text_field :content, class: "card-content"
+end
+
+event :validate_number, :validate do
+  errors.add :content, "'#{content}' is not numeric" unless valid_number?(content)
+end
+
+def valid_number? string
+  valid = true
+  begin
+    Kernel.Float(string)
+  rescue ArgumentError, TypeError
+    valid = false
+  end
+  valid
+end

data/mod/standard/set/type/phrase.rb

@@ -0,0 +1,3 @@
+view :editor do |_args|
+  text_field :content, class: "card-content"
+end

data/mod/standard/set/type/search_type.rb

@@ -0,0 +1,332 @@
+include_set Abstract::AceEditor
+
+def item_cards params={}
+  s = query(params)
+  raise("OH NO.. no limit") unless s[:limit]
+  # forces explicit limiting
+  # can be 0 or less to force no limit
+  Query.run(s, name)
+end
+
+def item_names params={}
+  statement = query params.merge(return: :name)
+  Query.run(statement, name)
+end
+
+def item_type
+  return if query[:type].is_a?(Array) || query[:type].is_a?(Hash)
+  query[:type]
+end
+
+def count params={}
+  Card.count_by_wql query(params)
+end
+
+def query params={}
+  @query ||= {}
+  @query[params.to_s] ||= get_query(params.clone)
+end
+
+def get_query params={}
+  # why is this a wagn_bot thing?  can't deny search content??
+  query = Auth.as_bot do
+    query_content = params.delete(:query) || raw_content
+    if query_content.empty?
+      raise JSON::ParserError,
+            "Error in card '#{name}':can't run search with empty content"
+    elsif query_content.is_a?(String)
+      JSON.parse(query_content)
+    else query_content
+    end
+  end
+  query.symbolize_keys!.merge! params.symbolize_keys
+  if (default_limit = query.delete(:default_limit))
+    query[:limit] ||= default_limit
+  end
+  query[:context] ||= cardname
+  query
+end
+
+format do
+  view :core do |args|
+    view =
+      case search_results args
+      when Exception          then :search_error
+      when Integer            then :search_count
+      when @mode == :template then :raw
+      else                         :card_list
+      end
+    _render view, args
+  end
+
+  view :search_count do |_args|
+    search_results.to_s
+  end
+
+  view :search_error do |_args|
+    sr_class = search_results.class.to_s
+    %(#{sr_class} :: #{search_results.message} :: #{card.raw_content})
+  end
+
+  view :card_list do |_args|
+    if search_results.empty?
+      "no results"
+    else
+      search_results.map do |c|
+        nest c
+      end.join "\n"
+    end
+  end
+
+  def search_vars args={}
+    @search_vars ||=
+      begin
+        v = {}
+        v[:query] = card.query(search_params)
+        v[:item] = set_nest_opts args.merge(query_view: v[:query][:view])
+        v
+      rescue JSON::ParserError => e
+        { error: e }
+      end
+  end
+
+  def search_results args={}
+    @search_results ||= begin
+      search_vars args
+      if search_vars[:error]
+        search_vars[:error]
+      else
+        begin
+          raw_results = card.item_cards search_params
+          is_count = search_vars[:query][:return] == "count"
+          is_count ? raw_results.to_i : raw_results
+        rescue Card::Error::BadQuery => e
+          e
+        end
+      end
+    end
+  end
+
+  def search_result_names
+    @search_result_names ||=
+      begin
+        card.item_names search_params
+      rescue => e
+        { error: e }
+      end
+  end
+
+  def each_reference_with_args args={}
+    search_result_names.each do |name|
+      yield(name, nest_args(args.reverse_merge!(item: :content)))
+    end
+  end
+
+  def set_nest_opts args
+    @nest_defaults = nil
+    @nest_opts ||= {}
+    @nest_opts[:view] = args[:item] || nest_opts[:view] ||
+                        args[:query_view] || default_item_view
+    # explicit > nest syntax > WQL > nest defaults
+  end
+
+  def page_link text, page, _current=false, options={}
+    @paging_path_args[:offset] = page * @paging_limit
+    options[:class] = "card-paging-link slotter"
+    options[:remote] = true
+    link_to raw(text), path(@paging_path_args), options
+  end
+
+  def page_li text, page, current=false, options={}
+    css_class = if current
+                  "active"
+                elsif !page
+                  "disabled"
+                end
+    page ||= 0
+    content_tag :li, class: css_class do
+      page_link text, page, current, options
+    end
+  end
+
+  def previous_page_link page
+    page_li '<span aria-hidden="true">&laquo;</span>', page, false,
+            "aria-label" => "Previous"
+  end
+
+  def next_page_link page
+    page_li '<span aria-hidden="true">&raquo;</span>', page, false,
+            "aria-label" => "Next"
+  end
+
+  def ellipse_page
+    content_tag :li, content_tag(:span, "...")
+  end
+
+  def chunk_list
+    :query
+  end
+end
+
+format :data do
+  view :card_list do |_args|
+    search_results.map do |c|
+      nest c
+    end
+  end
+end
+
+format :csv do
+  view :card_list do |args|
+    items = super args
+    if @depth == 0
+      render_csv_title_row + items
+    else
+      items
+    end
+  end
+end
+
+format :json do
+  def default_search_params
+    set_default_search_params default_limit: 0
+  end
+
+  view :export do |args|
+    # avoid running the search from options and structure that
+    # case a huge result or error
+    return [render_atom(args)] if card.content.empty? ||
+                                  card.name.include?("+*options") ||
+                                  card.name.include?("+*structure")
+    super(args)
+  end
+
+  view :export_items do |args|
+    card.item_names(limit: 0).map do |i_name|
+      next unless (i_card = Card[i_name])
+      subformat(i_card).render_atom(args)
+    end.flatten.reject(&:blank?)
+  end
+end
+
+format :rss do
+  view :feed_body do |args|
+    case raw_feed_items args
+    when Exception then @xml.item(render(:search_error))
+    when Integer then @xml.item(render(:search_count))
+    else super args
+    end
+  end
+
+  def raw_feed_items _args
+    @raw_feed_items ||= begin
+      search_params[:default_limit] = 25
+      search_results
+    end
+  end
+end
+
+format :html do
+  def default_editor_args args
+    args[:ace_mode] = "json"
+  end
+
+  view :card_list do |args|
+    paging = _optional_render :paging, args
+
+    if search_results.empty?
+      render_no_search_results(args)
+    else
+      results =
+        search_results.map do |c|
+          item_view = nest_defaults(c)[:view]
+          %(
+            <div class="search-result-item item-#{item_view}">
+              #{nest(c, size: args[:size], view: item_view)}
+            </div>
+          )
+        end.join "\n"
+
+      %(
+        #{paging}
+        <div class="search-result-list">
+          #{results}
+        </div>
+        #{paging if search_results.length > 10}
+      )
+    end
+  end
+
+  view :closed_content do |args|
+    if @depth > self.class.max_depth
+      "..."
+    else
+      search_limit = args[:closed_search_limit]
+      search_params[:limit] =
+        search_limit && [search_limit, Card.config.closed_search_limit].min
+      _render_core args.merge(hide: "paging", item: :link)
+      # TODO: if item is queryified to be "name", then that should work.
+      # otherwise use link
+    end
+  end
+
+  view :no_search_results do |_args|
+    %(<div class="search-no-results"></div>)
+  end
+
+  view :paging do |args|
+    s = card.query search_params
+    offset = s[:offset].to_i
+    limit = s[:limit].to_i
+    return "" if limit < 1
+    # avoid query if we know there aren't enough results to warrant paging
+    return "" if offset == 0 && limit > offset + search_results.length
+    total = card.count search_params
+    # should only happen if limit exactly equals the total
+    return "" if limit >= total
+    @paging_path_args = { limit: limit,
+                          slot: {
+                            item: args[:item] || nest_defaults(card)[:view]
+                          } }
+    @paging_path_args[:view] = args[:home_view] if args[:home_view]
+    @paging_limit = limit
+
+    s[:vars].each { |key, value| @paging_path_args["_#{key}"] = value }
+
+    out = ['<nav><ul class="pagination paging">']
+
+    total_pages = ((total - 1) / limit).to_i
+    current_page = (offset / limit).to_i # should already be integer
+    window = 2 # should be configurable
+    window_min = current_page - window
+    window_max = current_page + window
+
+    previous_page = current_page > 0 ? current_page - 1 : false
+    out << previous_page_link(previous_page)
+    if window_min > 0
+      out << page_li(1, 0)
+      out << ellipse_page if window_min > 1
+    end
+
+    (window_min..window_max).each do |page|
+      next if page < 0 || page > total_pages
+      text = page + 1
+      out << page_li(text, page, page == current_page)
+    end
+
+    if total_pages > window_max
+      out << ellipse_page if total_pages > window_max + 1
+      out << page_li(total_pages + 1, total_pages)
+    end
+
+    next_page = current_page < total_pages ? current_page + 1 : false
+    out << next_page_link(next_page)
+
+    out << %(</ul></nav>)
+    out.join
+  end
+
+  def default_search_params
+    set_default_search_params default_limit: 20
+  end
+end