card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod020-search/abstract/search/views.rb

@@ -0,0 +1,168 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Search;
+# Set: Abstract (Search, Views)
+#
+module Views;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/search/views.rb"; end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  view :search_count, cache: :never do
+    search_with_params.to_s
+  end
+
+  view :search_error, cache: :never do
+    sr_class = search_with_params.class.to_s
+    %(#{sr_class} :: #{search_with_params.message} :: #{card.content})
+  end
+
+  view :card_list, cache: :never do
+    if search_with_params.empty?
+      "no results"
+    else
+      search_with_params.map do |item_card|
+        nest_item item_card
+      end.join "\n"
+    end
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  AUTOCOMPLETE_LIMIT = 8 # number of name suggestions for autocomplete text fields
+
+  def item_cards
+    search_with_params
+  end
+
+  # NOCACHE because paging_urls is uncacheable hash and thus not safe to merge
+  view :molecule, cache: :never do
+    molecule.merge render_paging_urls
+  end
+
+  # TODO: design better autocomplete API
+  view :name_complete, cache: :never do
+    complete_search limit: AUTOCOMPLETE_LIMIT
+  end
+
+  view :name_match, cache: :never do
+    complete_or_match_search limit: AUTOCOMPLETE_LIMIT
+  end
+
+  def complete_or_match_search limit: AUTOCOMPLETE_LIMIT
+    starts_with = complete_search limit: limit
+    return starts_with if Card.config.navbox_match_start_only
+
+    remaining_slots = limit - starts_with.size
+    return starts_with if remaining_slots.zero?
+    starts_with + match_search(not_names: starts_with, limit: remaining_slots)
+  end
+
+  def complete_search limit: AUTOCOMPLETE_LIMIT
+    card.search name_wql(limit).merge(complete_wql)
+  end
+
+  def match_search limit: AUTOCOMPLETE_LIMIT, not_names: []
+    card.search name_wql(limit).merge(match_wql(not_names))
+  end
+
+  def name_wql limit
+    { limit: limit, sort: "name", return: "name" }
+  end
+
+  def complete_wql
+    { complete: term_param }
+  end
+
+  def match_wql not_names
+    wql = { name_match: term_param }
+    wql[:name] = ["not in"] + not_names if not_names.any?
+    wql
+  end
+
+  def term_param
+    params[:term]
+  end
+end
+
+module DataFormat; parent.send :register_set_format, Card::Format::DataFormat, self; extend Card::Set::AbstractFormat
+  view :card_list do
+    search_with_params.map do |item_card|
+      nest_item item_card
+    end
+  end
+end
+
+module CsvFormat; parent.send :register_set_format, Card::Format::CsvFormat, self; extend Card::Set::AbstractFormat
+  view :core, :core, mod: All::AllCsv::CsvFormat
+
+  view :card_list do
+    items = super()
+    if depth.zero?
+      title_row + items
+    else
+      items
+    end
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :card_list, cache: :never do
+    with_results do
+      search_result_list "search-result-list" do |item_card|
+        card_list_item item_card
+      end
+    end
+  end
+
+  view :select_item, cache: :never do
+    wrap do
+      haml :select_item
+    end
+  end
+
+  before :select_item do
+    class_up "card-slot", "_filter-result-slot"
+  end
+
+  view :checkbox_list, cache: :never do
+    with_results do
+      search_result_list "_search-checkbox-list pr-2" do |item_card|
+        checkbox_item item_card
+      end
+    end
+  end
+
+  view :no_search_results do
+    wrap_with :div, "", class: "search-no-results"
+  end
+
+  private
+
+  def card_list_item item_card
+    nest_item item_card, size: voo.size do |rendered, item_view|
+      %(<div class="search-result-item item-#{item_view}">#{rendered}</div>)
+    end
+  end
+
+  def search_result_list klass
+    with_paging do
+      wrap_with :div, class: klass do
+        search_with_params.map do |item_card|
+          yield item_card
+        end
+      end
+    end
+  end
+
+  def checkbox_item item_card
+    subformat(item_card).wrap do
+      haml :checkbox_item, unique_id: unique_id, item_card: item_card
+    end
+  end
+
+  def closed_limit
+    [search_params[:limit].to_i, Card.config.closed_search_limit].min
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/search/views.rb ~~

data/tmpsets/set/mod020-search/abstract/wql_search.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (WqlSearch)
+#
+module WqlSearch;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/abstract/wql_search.rb"; end
+include_set Abstract::Search
+
+def search args={}
+  with_skipping args do
+    query = fetch_query(args)
+    # forces explicit limiting
+    # can be 0 or less to force no limit
+    raise "OH NO.. no limit" unless query.mods[:limit]
+    query.run
+  end
+end
+
+# for override, eg when required subqueries are known to be missing
+def skip_search?
+  false
+end
+
+def with_skipping args
+  skip_search? ? skipped_search_result(args) : yield
+end
+
+def skipped_search_result args={}
+  args[:return] == :count ? 0 : []
+end
+
+def cache_query?
+  true
+end
+
+def fetch_query args={}
+  @query = nil unless cache_query?
+  @query ||= {}
+  @query[args.to_s] ||= query(args.clone) # cache query
+end
+
+def query args={}
+  Query.new standardized_query_args(args), name
+end
+
+def standardized_query_args args
+  args = query_args(args).symbolize_keys
+  args[:context] ||= name
+  args
+end
+
+# override this to define search
+def wql_hash
+  @wql_hash = nil unless cache_query?
+  @wql_hash ||= wql_from_content.merge filter_and_sort_wql
+end
+
+def wql_from_content
+  @wql_from_content = nil unless cache_query?
+  @wql_from_content ||= begin
+    query = content
+    query = query.is_a?(Hash) ? query : parse_json_query(query)
+    query.symbolize_keys
+  end
+end
+
+def query_args args={}
+  wql_hash.merge args
+end
+
+def parse_json_query query
+  empty_query_error! if query.empty?
+  JSON.parse query
+rescue
+  raise Error::BadQuery, "Invalid JSON search query: #{query}"
+end
+
+def empty_query_error!
+  raise Error::BadQuery,
+        "Error in card '#{name}':can't run search with empty content"
+end
+
+def item_type
+  type = wql_hash[:type]
+  return if type.is_a?(Array) || type.is_a?(Hash)
+  type
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def default_limit
+    card_content_limit || super
+  end
+
+  def card_content_limit
+    card.wql_hash[:limit]
+  rescue
+    nil
+  end
+
+  def item_view_from_query
+    query_with_params.statement[:item]
+  end
+
+  def query_with_params
+    @query_with_params ||= card.fetch_query search_params
+  end
+
+  def limit
+    query_with_params.limit
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def default_limit
+    card_content_limit || super
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/abstract/wql_search.rb ~~

data/tmpsets/set/mod020-search/self/navbox.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Self
+# Set: The card "Navbox"
+#
+module Navbox;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/self/navbox.rb"; end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :raw do
+    wrap_with :div, class: "form-group w-100" do
+      select_tag "query[keyword]", "", class: "_navbox navbox form-control w-100",
+                                       placeholder: navbar_placeholder
+    end
+  end
+
+  # TODO: the more natural placeholder would be the content of the navbox card, no?
+  # Also, the forced division of "raw" and "core" should probably be replaced
+  # with a single haml template (for core view)
+  def navbar_placeholder
+    @@placeholder ||= begin
+      holder_card = Card["#{Card[:navbox].name}+*placeholder"]
+      holder_card ? holder_card.content : "Search"
+    end
+  end
+
+  view :navbar do
+    class_up "navbox-form", "form-inline col-md-6"
+    _render_core
+  end
+
+  view :core do
+    form_tag path(mark: :search),
+             method: "get", role: "search",
+             class: classy("navbox-form", "nodblclick") do
+      _render_raw
+    end
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/self/navbox.rb ~~

data/tmpsets/set/mod020-search/self/recent.rb

@@ -0,0 +1,44 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Self
+# Set: The card "Recent"
+#
+module Recent;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/self/recent.rb"; end
+ACTS_PER_PAGE = 25
+
+view :title do
+  voo.title = "Recent Changes"
+  super()
+end
+
+def recent_acts
+  action_relation = qualifying_actions.where "card_acts.id = card_act_id"
+  Act.where("EXISTS (#{action_relation.to_sql})").order id: :desc
+end
+
+def qualifying_actions
+  Action.all_viewable.where "draft is not true"
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :core do
+    voo.hide :history_legend unless voo.main
+    @acts_per_page = ACTS_PER_PAGE
+    acts_layout card.recent_acts, :absolute
+  end
+end
+
+module RssFormat; parent.send :register_set_format, Card::Format::RssFormat, self; extend Card::Set::AbstractFormat
+  view :feed_item_description do
+    render_blank
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  def items_for_export
+    card.item_cards limit: 20
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/self/recent.rb ~~

data/tmpsets/set/mod020-search/self/search.rb

@@ -0,0 +1,103 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Self
+# Set: The card "Search"
+#
+module Search;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/search/set/self/search.rb"; end
+def query_args args={}
+  return super unless keyword_contains_wql? args
+  args.merge parse_keyword_wql(args)
+end
+
+def parse_keyword_wql args
+  parse_json_query(args[:vars][:keyword])
+end
+
+def keyword_contains_wql? hash
+  hash[:vars] && (keyword = hash[:vars][:keyword]) && keyword =~ /^\{.+\}$/
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  view :search_error, cache: :never do
+    sr_class = search_with_params.class.to_s
+
+    # don't show card content; not very helpful in this case
+    %(#{sr_class} :: #{search_with_params.message})
+  end
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  view :title, cache: :never do
+    return super() unless (keyword = search_keyword) &&
+                          (title = keyword_search_title(keyword))
+    voo.title = title
+  end
+
+  def keyword_search_title keyword
+    %(Search results for: <span class="search-keyword">#{h keyword}</span>)
+  end
+
+  def search_keyword
+    (vars = search_vars) && vars[:keyword]
+  end
+
+  def search_vars
+    root.respond_to?(:search_params) ? root.search_params[:vars] : search_params[:vars]
+  end
+
+  def wql_search?
+    card.keyword_contains_wql? vars: search_vars
+  end
+end
+
+module JsonFormat; parent.send :register_set_format, Card::Format::JsonFormat, self; extend Card::Set::AbstractFormat
+  view :complete, cache: :never do
+    term = term_param
+    exact = Card.fetch term, new: {}
+
+    {
+      search: true,
+      term: term,
+      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.name.valid? &&
+                  !exact.virtual? &&
+                  exact.ok?(:create)
+    [h(exact.name), exact.name.url_key]
+  end
+
+  def new_item_of_type exact
+    return unless (exact.type_id == Card::CardtypeID) &&
+                  Card.new(type_id: exact.id).ok?(:create)
+    [exact.name, "new/#{exact.name.url_key}"]
+  end
+
+  def goto_items term, exact
+    goto_names = complete_or_match_search
+    goto_names.unshift exact.name if add_exact_to_goto_names? exact, goto_names
+    goto_names.map do |name|
+      [name, name.to_name.url_key, h(highlight(name, term, sanitize: false))]
+    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 term_param
+    term = query_params[:keyword]
+    if (term =~ /^\+/) && (main = params["main"])
+      term = main + term
+    end
+    term
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/search/set/self/search.rb ~~