card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod003-core/all/fetch_helper.rb

@@ -0,0 +1,162 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (FetchHelper)
+#
+module FetchHelper;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb"; end
+module ClassMethods
+  # a fetch method to support the needs of the card controller.
+  # should be in Decko?
+  def controller_fetch args
+    card_opts = controller_fetch_opts args
+    if args[:action] == "create"
+      # FIXME: we currently need a "new" card to catch duplicates
+      # (otherwise save will just act like a normal update)
+      # We may need a "#create" instance method to handle this checking?
+      Card.new card_opts
+    else
+      standard_controller_fetch args, card_opts
+    end
+  end
+
+  def safe_param param
+    if param.respond_to? :to_unsafe_h
+      # clone doesn't work for Parameters
+      param.to_unsafe_h
+    else
+      # clone so that original params remain unaltered.  need deeper clone?
+      (param || {}).clone
+    end
+  end
+
+  private
+
+  def standard_controller_fetch args, card_opts
+    mark = args[:mark] || card_opts[:name]
+    card = Card.fetch mark, look_in_trash: args[:look_in_trash], new: card_opts
+    card.assign_attributes card_opts if args[:assign] && card&.real?
+    card
+  end
+
+  def controller_fetch_opts args
+    opts = safe_param args[:card]
+    opts[:type] ||= args[:type] if args[:type]
+    # for /new/:type shortcut.  we should handle in routing and deprecate this
+    opts[:name] ||= Card::Name.url_key_to_standard(args[:mark])
+    opts
+  end
+
+  def validate_fetch_opts! opts
+    return unless opts[:new] && opts[:skip_virtual]
+    raise Card::Error, "fetch called with new args and skip_virtual"
+  end
+
+  def skip_type_lookup? opts
+    # if opts[:new] is not empty then we are initializing a variant that is
+    # different from the cached variant
+    # and can postpone type lookup for the cached variant
+    # if skipping virtual no need to look for actual type
+    opts[:skip_virtual] || opts[:new].present? || opts[:skip_type_lookup]
+  end
+
+  def retrieve_or_new mark, opts
+    card, needs_caching = retrieve_existing mark, opts
+    if (new_card = new_for_cache card, mark, opts)
+      [new_card, true]
+    else
+      [card, needs_caching]
+    end
+  end
+
+  # look in cache.  if that doesn't work, look in database
+  # @return [{Card}, {True/False}] Card object and "needs_caching" ruling
+  def retrieve_existing mark, opts
+    return [nil, false] unless mark.present?
+    mark_type, mark_key = retrievable_mark_type_and_value mark
+    if (card = retrieve_from_cache_by_mark mark_type, mark_key, opts)
+      # we have an acceptable card in the cache
+      # (and don't need to cache it again!)
+      [card, false]
+    else
+      # try to find the card in the database
+      card = retrieve_from_db mark_type, mark_key, opts[:look_in_trash]
+      [card, !(card.nil? || card.trash)]
+    end
+  end
+
+  def retrieve_from_cache_by_mark mark_type, mark_key, opts
+    card = send "retrieve_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
+    return_cached_card?(card, opts[:look_in_trash]) ? card : nil
+  end
+
+  # In both the cache and the db, ids and keys are used to retrieve card data.
+  # This method identifies the kind of mark to use and its value
+  # @return [Array] first item is :id or :key, second is corresponding value
+  def retrievable_mark_type_and_value mark
+    # return mark_type and mark_value
+    if mark.is_a? Integer
+      [:id, mark]
+    else
+      [:key, mark.key]
+    end
+  end
+
+  def return_cached_card? card, look_in_trash
+    return false unless card
+    card.real? || !look_in_trash
+  end
+
+  # @return [Card, nil] Card object
+  def retrieve_from_db mark_type, mark_key, look_in_trash=false
+    query = { mark_type => mark_key }
+    query[:trash] = false unless look_in_trash
+    Card.where(query).take
+  end
+
+  def standard_fetch_results card, mark, opts
+    if card.new_card?
+      new_card_fetch_results card, mark, opts
+    else
+      finalize_fetch_results card, opts
+    end
+  end
+
+  def new_card_fetch_results card, mark, opts
+    case
+      when opts[:new].present? then return card.renew(opts)
+      when opts[:new] # noop for empty hash
+      when opts[:skip_virtual] then return nil
+    end
+    card.assign_name_from_fetched_mark! mark, opts
+    finalize_fetch_results card, opts
+    card if opts[:new] || card.known?
+  end
+
+  def finalize_fetch_results card, opts
+    card.include_set_modules unless opts[:skip_modules]
+    card
+  end
+
+  def normalize_fetch_args args
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    mark = id_or_name args
+    mark = absolutize_fetch_mark mark, opts.dig(:new, :supercard)
+    [mark, opts]
+  end
+
+  def absolutize_fetch_mark mark, supercard
+    return mark unless mark.name? && supercard
+    mark.to_name.absolute_name supercard.name
+  end
+end
+
+public
+
+def assign_name_from_fetched_mark! mark, opts
+  return if opts[:local_only]
+  return unless mark && mark.to_s != name
+  self.name = mark.to_s
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb ~~

data/tmpsets/set/mod003-core/all/haml.rb

@@ -0,0 +1,84 @@
+# -*- 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/core/set/all/haml.rb"; end
+module Format; 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/core/set/all/haml.rb ~~

data/tmpsets/set/mod003-core/all/i18n.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (I18n)
+#
+module I18n;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/i18n.rb"; end
+
+def tr key, args={}
+  ::I18n.t key, args.reverse_merge(scope: Card::Set.scope(caller))
+end
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  def tr key, args={}
+    ::I18n.t key, args.reverse_merge(scope: Card::Set.scope(caller))
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/i18n.rb ~~

data/tmpsets/set/mod003-core/all/initialize.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Initialize)
+#
+module Initialize;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/initialize.rb"; end
+JUNK_INIT_ARGS = %w[missing skip_virtual id].freeze
+
+module ClassMethods
+  def new args={}, _options={}
+    args = (args || {}).stringify_keys
+    JUNK_INIT_ARGS.each { |a| args.delete(a) }
+    %w[type type_code].each { |k| args.delete(k) if args[k].blank? }
+    args.delete("content") if args["attach"] # should not be handled here!
+    super args
+  end
+end
+
+def initialize args={}
+  args["name"] = initial_name args["name"]
+  args["db_content"] = args.delete "content" if args["content"]
+  @supercard = args.delete "supercard" # must come before name=
+
+  handle_skip_args args do
+    super args # ActiveRecord #initialize
+  end
+  self
+end
+
+def handle_skip_args args
+  skip_modules = args.delete "skip_modules"
+  skip_type_lookup = args["skip_type_lookup"]
+  yield
+  self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
+  include_set_modules unless skip_modules
+end
+
+def initial_name name
+  return name if name.is_a? String
+  Card::Name[name].to_s
+end
+
+def include_set_modules
+  unless @set_mods_loaded
+    set_modules.each do |m|
+      singleton_class.send :include, m
+    end
+    assign_set_specific_attributes
+    @set_mods_loaded = true
+  end
+  self
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/initialize.rb ~~

data/tmpsets/set/mod003-core/all/item.rb

@@ -0,0 +1,123 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Item)
+#
+module Item;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/item.rb"; end
+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 include_item? item
+  key = item.is_a?(Card) ? item.name.key : item.to_name.key
+  item_names.map { |name| name.to_name.key }.member? key
+end
+
+def add_item item
+  return if include_item? item
+  self.content = "#{content}\n#{item}"
+end
+
+def drop_item item
+  return unless include_item? item
+  new_names = item_names.reject { |i| i == item }
+  self.content = new_names.empty? ? "" : new_names.join("\n")
+end
+
+def insert_item index, name
+  new_names = item_names
+  new_names.delete name
+  new_names.insert index, name
+  self.content = new_names.join "\n"
+end
+
+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
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  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
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def wrap_item rendered, item_view
+    %(<div class="item-#{item_view}">#{rendered}</div>)
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/item.rb ~~

data/tmpsets/set/mod003-core/all/layouts.rb

@@ -0,0 +1,43 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Layouts)
+#
+module Layouts;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/layouts.rb"; end
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  attr_reader :interior
+
+  def layout_nest
+    wrap_main { interior }
+  end
+
+  layout :pre do  # {{_main|raw}}
+    wrap_with :pre do
+      layout_nest
+    end
+  end
+
+  layout :simple do
+    layout_nest
+  end
+
+  layout :no_side do # {{_main|open}}
+    <<-HTML.strip_heredoc
+      <header>#{nest :header, view: :core}</header>
+      <article>#{layout_nest}</article>
+      <footer>{nest :footer, view: :core}</footer>
+    HTML
+  end
+
+  layout :default do
+    <<-HTML.strip_heredoc
+      <header>#{nest :header, view: :core}</header>
+      <article>#{layout_nest}</article>
+      <aside>#{nest :sidebar, view: :core}</aside>
+      <footer>{nest :footer, view: :core}</footer>
+    HTML
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/layouts.rb ~~