card 1.18.6 → 1.19.0

data/tmpsets/set/mod001-core/abstract/code_file.rb

@@ -0,0 +1,79 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module CodeFile; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/abstract/code_file.rb ~~
+def self.included host_class
+  host_class.mattr_accessor :file_content_mod_name
+  host_class.file_content_mod_name = mod_name(caller)
+end
+
+# try to extract the mod name from the path of the set's tmp file
+# the caller that included the set file is set.rb
+def self.mod_name backtrace
+  mod_dir = tmp_mod_dir backtrace
+  raise Error, "not a valid set path: #{path}" unless mod_dir
+  match = mod_dir.match(/^mod\d+-(?<mod_name>.+)$/)
+  match[:mod_name]
+end
+
+def self.tmp_mod_dir backtrace
+  path = backtrace.find { |line| line.include? "tmp/set/" }
+  raise Error, "couldn't find set path in backtrace: #{backtrace}" unless path
+  path_parts = path.split(File::SEPARATOR)
+  path_parts.fetch(path_parts.index("set") + 1) do
+    raise Error, "not a valid set path: #{path}"
+  end
+end
+
+# @return [Array<String>, String] the name of file(s) to be loaded
+def source_files
+  case type_id
+  when CoffeeScriptID then "#{codename}.js.coffee"
+  when JavaScriptID then "#{codename}.js"
+  when CssID then "#{codename}.css"
+  when ScssID then "#{codename}.scss"
+  end
+end
+
+def source_dir
+  case type_id
+  when CoffeeScriptID, JavaScriptID then "javascript"
+  when CssID, ScssID then "stylesheets"
+  end
+end
+
+def find_file filename
+  Card.paths["mod"].to_a.each do |mod_path|
+    file_path =
+      File.join(mod_path, file_content_mod_name, "lib", source_dir, filename)
+    return file_path if File.exist? file_path
+  end
+  nil
+end
+
+def existing_source_paths
+  Array.wrap(source_files).map do |filename|
+    find_file(filename)
+  end.compact
+end
+
+view :raw do |_args|
+  Array.wrap(card.source_files).map do |filename|
+    if (source_path = card.find_file(filename))
+      Rails.logger.info "reading file: #{source_path}"
+      File.read source_path
+    else
+      Rails.logger.info "couldn't locate file: #{filename}"
+      nil
+    end
+  end.compact.join "\n"
+end
+
+format :html do
+  view :editor do |_args|
+    "Content is stored in file and can't be edited."
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/abstract/code_file.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-core/all/actify.rb

@@ -0,0 +1,100 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Actify; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/actify.rb ~~
+
+# The Card#abort method is for cleanly exiting an action without continuing
+# to process any further events.
+#
+# Three statuses are supported:
+#
+#   failure: adds an error, returns false on save
+#   success: no error, returns true on save
+#   triumph: similar to success, but if called on a subcard
+#            it causes the entire action to abort (not just the subcard)
+def abort status, msg="action canceled"
+  director.abort
+  if status == :failure && errors.empty?
+    errors.add :abort, msg
+  elsif status.is_a?(Hash) && status[:success]
+    success << status[:success]
+    status = :success
+  end
+  raise Card::Error::Abort.new(status, msg)
+end
+
+module ClassMethods
+  def create! opts
+    card = Card.new opts
+    card.act do
+      card.save!
+    end
+    card
+  end
+
+  def create opts
+    card = Card.new opts
+    card.act do
+      card.save
+    end
+    card
+  end
+end
+
+def save!(*)
+  act { super }
+end
+
+def save(*)
+  act { super }
+end
+
+def valid?(*)
+  act { super }
+end
+
+def update_attributes(*)
+  act { super }
+end
+
+def update_attributes!(*)
+  act { super }
+end
+
+def abortable
+  yield
+rescue Card::Error::Abort => e
+  if e.status == :triumph
+    @supercard ? raise(e) : true
+  elsif e.status == :success
+    if @supercard
+      @supercard.subcards.delete key
+      @supercard.director.subdirectors.delete self
+      expire_soft
+    end
+    true
+  end
+end
+
+# this is an override of standard rails behavior that rescues abort
+# makes it so that :success abortions do not rollback
+def with_transaction_returning_status
+  status = nil
+  self.class.transaction do
+    add_to_transaction
+    status = abortable { yield }
+    raise ActiveRecord::Rollback unless status
+  end
+  status
+end
+
+event :notable_exception_raised do
+  Rails.logger.debug "BT:  #{Card::Error.current.backtrace * "\n  "}"
+end
+
+def success
+  Env.success(cardname)
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/actify.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-core/all/active_card.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module ActiveCard; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/active_card.rb ~~
+=begin
+
+# following may be useful, but is neither tested nor in use
+
+def card_attributes
+  if Card::Set.traits
+    set_modules.each do |mod|
+      if mod_traits = Card::Set.traits[mod]
+        return mod_traits
+      end
+    end
+  end
+  nil
+end
+
+def trait_var? var_name
+  !instance_variable_get( var_name ).nil?
+end
+
+=end
+
+def trait_var _var_name, &_block
+  # FIXME: - following optimization attempt needs to handle cache clearing!
+  #  instance_variable_get var_name or begin
+  #    instance_variable_set var_name, block_given? ? yield : raise("no block?")
+  #  end
+  yield
+end
+
+# FIXME: -this needs a better home!
+def format opts={}
+  opts = { format: opts.to_sym } if [Symbol, String].member? opts.class
+
+  Card::Format.new self, opts
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/active_card.rb ~~
+end;end;end;end;

data/tmpsets/set/mod001-core/all/collection.rb

@@ -0,0 +1,313 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Collection; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/collection.rb ~~
+
+module ClassMethods
+  def search spec, comment=nil
+    results = ::Card::Query.run(spec, comment)
+    if block_given? && results.is_a?(Array)
+      results.each { |result| yield result }
+    end
+    results
+  end
+
+  def count_by_wql spec
+    spec = spec.clone
+    spec.delete(:offset)
+    search spec.merge(return: "count")
+  end
+
+  def find_each options={}
+    # this is a copy from rails (3.2.16) and is needed because this
+    # is performed by a relation (ActiveRecord::Relation)
+    find_in_batches(options) do |records|
+      records.each { |record| yield record }
+    end
+  end
+
+  def find_in_batches options={}
+    if block_given?
+      super(options) do |records|
+        yield(records)
+        Card::Cache.reset_soft
+      end
+    else
+      super(options)
+    end
+  end
+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 collection?
+  item_cards != [self]
+end
+
+def item_type
+  nil
+end
+
+def item_keys args={}
+  item_names(args).map do |item|
+    item.to_name.key
+  end
+end
+
+def include_item? item
+  key = item.is_a?(Card) ? item.cardname.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#{name}"
+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 extended_item_cards context=nil
+  context = (context ? context.cardname : cardname)
+  args = { limit: "" }
+  items = item_cards(args.merge(context: context))
+  extended_list = []
+  already_extended = ::Set.new # avoid loops
+
+  until items.empty?
+    item = items.shift
+    next if already_extended.include? item
+    already_extended << item
+    if item.collection?
+      # keep items in order
+      items.unshift(*item.item_cards)
+    else  # no further level of items
+      extended_list << item
+    end
+  end
+  extended_list
+end
+
+def extended_item_contents context=nil
+  extended_item_cards(context).map(&:item_names).flatten
+end
+
+def extended_list context=nil
+  context = (context ? context.cardname : cardname)
+  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
+
+def contextual_content context_card, format_args={}, view_args={}
+  context_card.format(format_args).process_content(
+    format(format_args)._render_raw(view_args), view_args
+  )
+end
+
+format do
+  def item_links _args={}
+    raw(render_core).split(/[,\n]/)
+  end
+
+  def item_view args
+    args[:item] ||
+      (@nest_opts && @nest_opts[:view]) ||
+      default_item_view
+  end
+
+  def item_args args
+    i_args = { view: item_view(args) }
+    if (type = card.item_type)
+      i_args[:type] = type
+    end
+    i_args
+  end
+
+  def search_params
+    @search_params ||= begin
+      p = default_search_params.clone
+
+      if focal?
+        p[:offset] = params[:offset] if params[:offset]
+        p[:limit]  = params[:limit]  if params[:limit]
+        p.merge! params[:wql]        if params[:wql]
+      end
+      p
+    end
+  end
+
+  def default_search_params # wahh?
+    set_default_search_params
+  end
+
+  def set_default_search_params overrides={}
+    @default_search_params ||= begin
+      p = { default_limit: 100 }.merge overrides
+      set_search_params_variables! p
+      p
+    end
+  end
+
+  def set_search_params_variables! hash
+    hash[:vars] = params[:vars] || {}
+    params.each do |key, val|
+      case key.to_s
+      when "_wql"      then hash.merge! val
+      when /^\_(\w+)$/ then hash[:vars][Regexp.last_match(1).to_sym] = val
+      end
+    end
+  end
+
+  def each_reference_with_args args={}
+    content_object = Card::Content.new _render_raw(args), card
+    content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
+      yield chunk.referee_name.to_s, nest_args(args, chunk)
+    end
+  end
+
+  def each_nested_chunk args={}
+    content_object = Card::Content.new(_render_raw(args), card)
+    content_object.find_chunks(Card::Content::Chunk::Include).each do |chunk|
+      yield(chunk) if chunk.referee_name # filter commented nests
+    end
+  end
+
+  def nested_fields args={}
+    result = []
+    each_nested_field(args) do |chunk|
+      result << chunk
+    end
+    result
+  end
+
+  def unique_chunks chunk, processed_set, &_block
+    return if processed_set.include? chunk.referee_name.key
+    processed_set << chunk.referee_name.key
+    yield(chunk)
+  end
+
+  def each_nested_field args, &block
+    processed_chunk_keys = ::Set.new([card.key])
+
+    each_nested_chunk(args) do |chunk|
+      # TODO: handle structures that are non-virtual
+      next unless chunk.referee_name.to_name.field_of? card.name
+      if chunk.referee_card &&
+         chunk.referee_card.virtual? &&
+         !processed_chunk_keys.include?(chunk.referee_name.key)
+
+        processed_chunk_keys << chunk.referee_name.key
+        subformat(chunk.referee_card).each_nested_field(args) do |sub_chunk|
+          unique_chunks sub_chunk, processed_chunk_keys, &block
+        end
+      else
+        unique_chunks chunk, processed_chunk_keys, &block
+      end
+    end
+  end
+
+  def map_references_with_args args={}, &_block
+    result = []
+    each_reference_with_args args do |name, n_args|
+      result << yield(name, n_args)
+    end
+    result
+  end
+
+  # process args for links and nests
+  def nest_args args, chunk=nil
+    r_args = item_args(args)
+    r_args.merge! @nest_opts.clone if @nest_opts
+
+    case chunk
+    when Card::Content::Chunk::Include
+      r_args.merge!(chunk.options)
+    when Card::Content::Chunk::Link
+      r_args.reverse_merge!(view: :link)
+      r_args.reverse_merge!(title: chunk.link_text) if chunk.link_text
+    end
+    r_args
+  end
+end
+
+format :html do
+  view :count do |args|
+    card.item_names(args).size
+  end
+
+  view :tabs do |args|
+    active_name = nil
+    active_content = nil
+    tabs = {}
+    each_reference_with_args(item: :content) do |name, nest_args|
+      tab_name = nest_args[:title] || name
+      tabs[tab_name] = nest_path(name, nest_args).html_safe
+
+      active_name ||= tab_name
+      # warning: nest changes nest_args
+      active_content ||= nest(Card.fetch(name, new: {}), nest_args)
+    end
+    lazy_loading_tabs tabs, active_name, active_content,
+                      type: args[:tab_type]
+  end
+  def default_tabs_args args
+    args[:tab_type] ||= "tabs"
+  end
+
+  # create a path for a nest with respect ot the nest options
+  def nest_path name, nest_args
+    path_args = {}
+    path_args[:view] = nest_args[:view]
+    path_args[:slot] = nest_args.clone
+    path_args[:slot].delete(:view)
+    page_path(name, path_args)
+  end
+
+  view :pills, view: :tabs
+  def default_pills_args args
+    args[:tab_type] ||= "pills"
+  end
+
+  view :tabs_static do |args|
+    tabs = {}
+    card.item_cards.each do |item|
+      tabs[item.name] = nest item, item_args(args)
+    end
+    static_tabs tabs, args[:tab_type]
+  end
+  def default_tabs_static_args args
+    args[:tab_type] ||= "tabs"
+  end
+
+  view :pills_static, view: :tabs_static
+  def default_tabs_static_args args
+    args[:tab_type] ||= "pills"
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/collection.rb ~~
+end;end;end;end;