card 1.99.6 → 1.100.0

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

@@ -0,0 +1,44 @@
+# -*- 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
+
+  private
+
+  def standard_controller_fetch args, card_opts
+    mark = args[:mark] || card_opts[:name]
+    card = Card.fetch mark, skip_modules: true,
+                            look_in_trash: args[:look_in_trash],
+                            new: card_opts
+    card.assign_attributes card_opts if args[:assign] && card&.real?
+    card&.include_set_modules
+    card
+  end
+
+  def controller_fetch_opts args
+    opts = Env.hash 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
+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,85 @@
+# -*- 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={}
+    with_normalized_new_args args do |normalized_args|
+      super normalized_args
+    end
+  end
+
+  def with_normalized_new_args args={}
+    args = (args || {}).stringify_keys
+    delete_junk_args args
+    normalize_type_args args
+    normalize_content_args args
+    yield args
+  end
+
+  private
+
+  def delete_junk_args args
+    JUNK_INIT_ARGS.each { |a| args.delete(a) }
+  end
+
+  def normalize_type_args args
+    %w[type type_code].each { |k| args.delete(k) if args[k].blank? }
+  end
+
+  def normalize_content_args args
+    args.delete("content") if args["attach"] # should not be handled here!
+    args["db_content"] = args.delete "content" if args["content"]
+  end
+end
+
+def initialize args={}
+  args["name"] = initial_name args["name"]
+
+  handle_set_modules args do
+    handle_type args do
+      super args # ActiveRecord #initialize
+    end
+  end
+  self
+end
+
+def handle_set_modules args
+  skip_modules = args.delete "skip_modules"
+  yield
+  include_set_modules unless skip_modules
+end
+
+def handle_type args
+  type_lookup = args["type_lookup"]
+  @supercard = args.delete "supercard"
+
+  yield
+  type_id_from_template if type_lookup == :force || (!type_id && type_lookup != :skip)
+end
+
+def initial_name name
+  name.is_a?(String) ? name : Card::Name[name].to_s
+end
+
+def include_set_modules
+  return self if @set_mods_loaded
+
+  set_modules.each do |m|
+    singleton_class.send :include, m
+  end
+  assign_set_specific_attributes
+  @uncacheable = @set_mods_loaded = true
+  self
+end
+
+def uncacheable?
+  @uncacheable == true
+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,133 @@
+# -*- 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 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
+
+# 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
+
+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 ~~

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

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (LocationHistory)
+#
+module LocationHistory;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/location_history.rb"; end
+event :discard_deleted_locations, in: :finalize, on: :delete do
+  Env.discard_locations_for self
+  configure_successful_deletion if success.target == self
+end
+
+event :save_current_location, before: :show_page, on: :read do
+  Env.save_location self
+end
+
+# TO DISCUSS: should this default behavior be directly in the controller?
+# Or at least in decko?
+def configure_successful_deletion
+  if Env.ajax?
+    success.card = self
+    success.view = :unknown unless success.view
+  else
+    success.target = :previous
+  end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/location_history.rb ~~

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

@@ -0,0 +1,250 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Name)
+#
+module Name;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb"; end
+require "uuid"
+
+module ClassMethods
+  def uniquify_name name, rename=:new
+    return name unless Card.exists? name
+    uniq_name = generate_alternative_name name
+    return uniq_name unless rename == :old
+    rename!(name, uniq_name)
+    name
+  end
+
+  def generate_alternative_name name
+    uniq_name = "#{name} 1"
+    uniq_name.next! while Card.exists?(uniq_name)
+    uniq_name
+  end
+
+  def rename! oldname, newname
+    Card[oldname].update! name: newname, update_referers: true
+  end
+end
+
+def name
+  @name ||= left_id ? Card::Lexicon.lex_to_name([left_id, right_id]) : super.to_name
+end
+
+def key
+  @key ||= left_id ? name.key : super
+end
+
+def name= newname
+  @name = superize_name newname.to_name
+  self.key = @name.key
+  update_subcard_names @name
+  write_attribute :name, (@name.simple? ? @name.s : nil)
+  assign_side_ids
+  @name
+end
+
+def assign_side_ids
+  if name.simple?
+    self.left_id = self.right_id = nil
+  else
+    assign_side_id :left_id=, :left_name
+    assign_side_id :right_id=, :right_name
+  end
+end
+
+# assigns left_id and right_id based on names.
+# if side card is new, id is temporarily stored as -1
+def assign_side_id side_id_equals, side_name
+  side_id = Card::Lexicon.id(name.send(side_name)) || -1
+  send side_id_equals, side_id
+end
+
+def superize_name cardname
+  return cardname unless @supercard
+  @raw_name = cardname.s
+  @supercard.subcards.rename key, cardname.key
+  update_superleft cardname
+  cardname.absolute_name @supercard.name
+end
+
+def update_superleft cardname
+  @superleft = @supercard if cardname.field_of? @supercard.name
+end
+
+def key= newkey
+  return if newkey == key
+  update_cache_key key do
+    write_attribute :key, (name.simple? ? newkey : nil)
+    @key = newkey
+  end
+  clean_patterns
+  @key
+end
+
+def clean_patterns
+  return unless patterns?
+  reset_patterns
+  patterns
+end
+
+def update_cache_key oldkey
+  yield
+  was_in_cache = Card.cache.soft.delete oldkey
+  Card.write_to_soft_cache self if was_in_cache
+end
+
+def update_subcard_names new_name, name_to_replace=nil
+  return unless @subcards
+  subcards.each do |subcard|
+    update_subcard_name subcard, new_name, name_to_replace if subcard.new?
+  end
+end
+
+def update_subcard_name subcard, new_name, name_to_replace
+  name_to_replace ||= name_to_replace_for_subcard subcard, new_name
+  subcard.name = subcard.name.swap name_to_replace, new_name.s
+  subcard.update_subcard_names new_name, name # needed?  shouldn't #name= trigger this?
+end
+
+def name_to_replace_for_subcard subcard, new_name
+  # if subcard has a relative name like +C
+  # and self is a subcard as well that changed from +B to A+B then
+  # +C should change to A+B+C. #replace doesn't work in this case
+  # because the old name +B is not a part of +C
+  if subcard.name.starts_with_joint? && new_name.parts.first.present?
+    "".to_name
+  else
+    name
+  end
+end
+
+def autoname name
+  if Card.exists?(name) || ActManager.include?(name)
+    autoname name.next
+  else
+    name
+  end
+end
+
+# FIXME: use delegations and include all name functions
+def simple?
+  name.simple?
+end
+
+def junction?
+  name.junction?
+end
+
+def raw_name
+  @raw_name || name
+end
+
+def left *args
+  case
+  when simple?    then nil
+  when superleft then superleft
+  when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
+    nil # prevent recursion when, eg, renaming A+B to A+B+C
+  else
+    Card.fetch name.left, *args
+  end
+end
+
+def right *args
+  Card.fetch(name.right, *args) unless simple?
+end
+
+def [] *args
+  case args[0]
+  when Integer, Range
+    fetch_name = Array.wrap(name.parts[args[0]]).compact.join Card::Name.joint
+    Card.fetch(fetch_name, args[1] || {}) unless simple?
+  else
+    super
+  end
+end
+
+def trunk *args
+  simple? ? self : left(*args)
+end
+
+def tag *args
+  simple? ? self : Card.fetch(name.right, *args)
+end
+
+def left_or_new args={}
+  left(args) || Card.new(args.merge(name: name.left))
+end
+
+# NOTE: for all these helpers, method returns *all* fields/children/descendants.
+# (Not just those current user has permission to read.)
+
+def fields
+  field_ids.map { |id| Card[id] }
+end
+
+def field_names
+  field_ids.map { |id| Card::Name[id] }
+end
+
+def field_ids
+  child_ids :left
+end
+
+def each_child
+  child_ids.each do |id|
+    (child = Card[id]) && yield(child)
+    # check should not be needed (remove after fixing data problems)
+  end
+end
+
+# eg, A+B is a child of A and B
+def child_ids side=nil
+  return [] unless id
+  side ||= name.simple? ? :part : :left_id
+  Auth.as_bot do
+    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
+  end
+end
+
+def each_descendant &block
+  each_child do |child|
+    yield child
+    child.each_descendant(&block)
+  end
+end
+
+def right_id= card_or_id
+  write_card_or_id :right_id, card_or_id
+end
+
+def left_id= card_or_id
+  write_card_or_id :left_id, card_or_id
+end
+
+def write_card_or_id attribute, card_or_id
+  if card_or_id.is_a? Card
+    write_attribute_to_card attribute, card_or_id
+  else
+    write_attribute attribute, card_or_id
+  end
+end
+
+def write_attribute_to_card attribute, card
+  if card.id
+    write_attribute attribute, card.id
+  else
+    add_subcard card
+    card.director.prior_store = true
+    with_id_when_exists(card) do |id|
+      write_attribute attribute, id
+    end
+  end
+end
+
+def with_id_when_exists card, &block
+  card.director.call_after_store(&block)
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name.rb ~~