card 1.19.1 → 1.19.2

data/lib/card/subdirector_array.rb

@@ -1,43 +0,0 @@
-class Card
-  class SubdirectorArray < Array
-    def self.initialize_with_subcards parent
-      dir_array = new(parent)
-      parent.card.subcards.each_card do |subcard|
-        dir_array.add subcard
-      end
-      dir_array
-    end
-
-    def initialize parent
-      @parent = parent
-      super()
-    end
-
-    def add card, opts={}
-      if card.is_a? Card::StageDirector
-        card = card.card
-      end
-      each { |dir| return dir if dir.card == card }
-      dir = Card::DirectorRegister.fetch card, parent: @parent
-      dir.main = false
-      dir.parent = @parent
-      dir.transact_in_stage = opts[:transact_in_stage]
-      self << dir
-      dir
-    end
-
-    alias_method :delete_director, :delete
-
-    def delete card
-      if card.is_a? Card::StageDirector
-        delete_director card
-      else
-        delete_if { |dir| dir.card == card }
-      end
-    end
-
-    def add_director dir
-      add dir.card
-    end
-  end
-end

data/tmpsets/set/mod001-admin/self/admin.rb

@@ -1,130 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Self; module Admin; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/admin.rb ~~
-# collect arrays of the form
-# [task symbol, { execute_policy: block, stats_policy: block }]
-basket :tasks
-
-event :admin_tasks, :initialize, on: :update do
-  return unless (task = Env.params[:task])
-  raise Card::Error::PermissionDenied, self unless Auth.always_ok?
-
-  case task.to_sym
-  when :clear_cache          then Card::Cache.reset_all
-  when :repair_references    then Card::Reference.repair_all
-  when :clear_view_cache     then Card::Cache::ViewCache.reset
-  when :delete_old_revisions then Card::Action.delete_old
-  when :repair_permissions   then Card.repair_all_permissions
-  when :clear_solid_cache    then Card.clear_solid_cache
-  when :clear_machine_cache  then Card.reset_all_machines
-  else
-    task_data = tasks.find { |h| h[:name].to_sym == task }
-    task_data[:execute_policy].call if task_data
-  end
-  abort :success
-end
-
-format :html do
-  view :core do |_args|
-    stats = card_stats
-    stats += cache_stats
-    stats += memory_stats
-    card.tasks.each do |task|
-      stats += Array.wrap task[:stats]
-    end
-    table_content = stats.map { |args| stat_row(args) }
-    table table_content, header: %w(Stat Value Action)
-  end
-
-  def card_stats
-    [
-      { title: "cards",
-        count: Card.where(trash: false) },
-      { title: "actions",
-        count: Card::Action,
-        link_text: "delete old",
-        task: "delete_old_revisions" },
-      { title: "references",
-        count: Card::Reference,
-        link_text: "repair all",
-        task: "repair_references" }
-    ]
-  end
-
-  def cache_stats
-    stats = [
-      { title: "solid cache",
-        count: solid_cache_count, unit: " cards",
-        link_text: "clear cache",
-        task: "clear_solid_cache" },
-      { title: "machine cache",
-        count: machine_cache_count, unit: " cards",
-        link_text: "clear cache",
-        task: "clear_machine_cache" }
-    ]
-    return stats unless Card.config.view_cache
-    stats << { title: "view cache",
-               count: Card::Cache::ViewCache,
-               link_text: "clear view cache",
-               task: "clear_view_cache" }
-  end
-
-  def memory_stats
-    oldmem = session[:memory]
-    session[:memory] = newmem = card.profile_memory
-    stats = [
-      { title: "memory now",
-        count: newmem, unit: "M",
-        link_text: "clear cache", task: "clear_cache" }
-    ]
-    return stats unless oldmem
-    stats << { title: "memory prev", count: oldmem, unit: "M" }
-    stats << { title: "memory diff", count: newmem - oldmem, unit: "M" }
-    stats
-  end
-
-  def stat_row args={}
-    res = [(args[:title] || "")]
-    res << "#{count(args[:count])}#{args[:unit]}"
-    return res unless args[:task]
-    path = card_path("update/:admin?task=#{args[:task]}")
-    res << link_to(args[:link_text] || args[:task], path)
-    res
-  end
-
-  def count counter
-    counter = counter.call if counter.is_a?(Proc)
-    counter.respond_to?(:count) ? counter.count : counter
-  end
-
-  def solid_cache_count
-    Card.search right: { codename: "solid_cache" }, return: "count"
-  end
-
-  def machine_cache_count
-    Card.search right: { codename: "machine_cache" }, return: "count"
-  end
-
-  def delete_sessions_link months
-    link_to months,
-            card_path("update/:admin?task=delete_old_sessions&months=#{months}")
-  end
-end
-
-def current_memory_usage
-  `ps -o rss= -p #{Process.pid}`.to_i
-end
-
-def profile_memory &block
-  before = current_memory_usage
-  if block_given?
-    instance_eval(&block)
-  else
-    before = 0
-  end
-  (current_memory_usage - before) / 1024.to_i
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/admin.rb ~~
-end;end;end;end;

data/tmpsets/set/mod001-admin/self/admin_info.rb

@@ -1,110 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Self; module AdminInfo; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/admin_info.rb ~~
-def clean_html?
-  false
-end
-
-format :html do
-  view :core do
-    warnings = []
-    if Card.config.action_mailer.perform_deliveries == false
-      warnings << email_warning
-    end
-    if Card.config.recaptcha_public_key ==
-       Card::Auth::Permissions::RECAPTCHA_DEFAULTS[:recaptcha_public_key] &&
-       card.rule(:captcha) == "1"
-      warnings << recaptcha_warning
-    end
-    return "" if warnings.empty?
-    alert :warning, dismissible: true do
-      render_warning_list warnings
-    end
-  end
-
-  def render_warning_list warnings
-    # 'ADMINISTRATOR WARNING'
-    admin_warn = I18n.t(:admin_warn,
-                        scope: "mod.admin.set.self.admin_info")
-    "<h6>#{admin_warn}</h6>".html_safe + list_group(
-      warnings,
-      items: { class: "list-group-item-warning" }
-    )
-  end
-
-  def email_warning
-    # "Email delivery is turned off."
-    # "Change settings in config/application.rb to send sign up notifications."
-    I18n.t(:email_off,
-           scope: "mod.admin.set.self.admin_info",
-           path: "config/application.rb")
-  end
-
-  def recaptcha_warning
-    warning =
-      if Card::Env.localhost?
-        # %(Your captcha is currently working with temporary settings.
-        #   This is fine for a local installation, but you will need new
-        #   recaptcha keys if you want to make this site public.)
-        I18n.t(:captcha_temp, scope: "mod.admin.set.self.admin_info")
-      else
-        # %(You are configured to use [[*captcha]], but for that to work
-        #   you need new recaptcha keys.)
-        process_content(I18n.t(:captcha_keys,
-                               scope: "mod.admin.set.self.admin_info"))
-      end
-    # 'Instructions'
-    instructions = I18n.t(:instructions,
-                          scope: "mod.admin.set.self.admin_info")
-    <<-HTML
-      <p>
-        #{warning}
-      </p>
-      <h4>#{instructions}</h4>
-      #{howto_add_new_recaptcha_keys}
-      #{howto_turn_captcha_off}
-    HTML
-  end
-
-  def instructions title, steps
-    steps = list_group steps
-    "#{title}#{steps}"
-  end
-
-  def howto_add_new_recaptcha_keys
-    instructions(
-      # 'How to add new recaptcha keys:'
-      I18n.t(:howto_add_keys, scope: "mod.admin.set.self.admin_info"),
-      [
-        # "1. Register your domain at #{web_link 'http://google.com/recaptcha'}"
-        I18n.t(:howto_register,
-               scope: "mod.admin.set.self.admin_info",
-               recaptcha_link: web_link("http://google.com/recaptcha")),
-        # "2. Add your keys to #{card_link :recaptcha_settings}"
-        I18n.t(:howto_add,
-               scope: "mod.admin.set.self.admin_info",
-               recaptcha_settings: card_link(:recaptcha_settings))
-      ]
-    )
-  end
-
-  def howto_turn_captcha_off
-    instructions(
-      # 'How to turn captcha off:'
-      I18n.t(:howto_turn_off, scope: "mod.admin.set.self.admin_info"),
-      [
-        # "1. Go to #{card_link :captcha}"
-        I18n.t(:howto_go,
-               scope: "mod.admin.set.self.admin_info",
-               captcha_card: card_link(:captcha)),
-        # '2. Update all *captcha rules to "no".'
-        I18n.t(:howto_update,
-               scope: "mod.admin.set.self.admin_info")
-      ]
-    )
-  end
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/admin_info.rb ~~
-end;end;end;end;

data/tmpsets/set/mod001-admin/self/version.rb

@@ -1,15 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Self; module Version; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/version.rb ~~
-# -*- encoding : utf-8 -*-
-require_dependency "card/version"
-
-view :raw do |_args|
-  Card::Version.release
-end
-
-view :core, :raw
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/admin/set/self/version.rb ~~
-end;end;end;end;

data/tmpsets/set/mod002-core/all/debug.rb

@@ -1,30 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Debug; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/debug.rb ~~
-def to_s
-  "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
-end
-
-def inspect
-  tags = []
-  tags << "trash"    if trash
-  tags << "new"      if new_card?
-  tags << "frozen"   if frozen?
-  tags << "readonly" if readonly?
-  tags << "virtual"  if @virtual
-  tags << "set_mods_loaded" if @set_mods_loaded
-
-  error_messages = errors.any? ? "<E*#{errors.full_messages * ', '}*>" : ""
-
-  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{tags * ','}}"
-end
-
-private
-
-def debug_type
-  "#{type_code || ''}:#{type_id}"
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/debug.rb ~~
-end;end;end;end;

data/tmpsets/set/mod002-core/all/update_read_rules.rb

@@ -1,91 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module UpdateReadRules; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/update_read_rules.rb ~~
-
-# FIXME: the following don't really belong here, but they have to come after
-# the reference stuff.  we need to organize a bit!
-
-event :update_ruled_cards, :finalize do
-  if is_rule?
-    # warn "updating ruled cards for #{name}"
-    self.class.clear_rule_cache
-    set = rule_set
-
-    if right_id == Card::ReadID && (name_changed? || trash_changed?)
-      update_read_ruled_cards set
-    end
-  end
-end
-
-def update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                       rule_class_index, set
-  set.item_cards(limit: 0).each_with_object(::Set.new) do |item_card, in_set|
-    in_set << item_card.key
-    next if cur_index < rule_class_index
-    item_card.update_read_rule
-  end
-end
-
-def update_read_rules_of_set_members set
-  return ::Set.new if trash || !(class_id = id_of_set_class(set))
-  rule_class_ids = set_patterns.map(&:pattern_id)
-  Auth.as_bot do
-    if (rule_class_index = rule_class_ids.index(class_id))
-      cur_index = rule_class_ids.index Card[read_rule_class].id
-      update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                         rule_class_index, set
-    else
-      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
-      ::Set.new
-    end
-  end
-end
-
-def id_of_set_class set
-  set && (set_class = set.tag) && set_class.id
-end
-
-def update_read_ruled_cards set
-  self.class.clear_read_rule_cache
-  Card.cache.reset # maybe be more surgical, just Auth.user related
-  expire # probably shouldn't be necessary,
-  # but was sometimes getting cached version when card should be in the
-  # trash.  could be related to other bugs?
-
-  updated = update_read_rules_of_set_members set
-
-  # then find all cards with me as read_rule_id that were not just updated
-  # and regenerate their read_rules
-  return if new_card?
-  Card.search(read_rule_id: id) do |card|
-    card.update_read_rule unless updated.include?(card.key)
-  end
-end
-
-event :process_read_rule_update_queue, :finalize do
-  Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
-  @read_rule_update_queue = []
-end
-
-event :expire_related, :finalize do
-  subcards.keys.each do |key|
-    Card.cache.soft.delete key
-  end
-  expire # FIXME: where do we put this. Here it deletes @stage
-  reset_patterns
-  if is_structure?
-    structuree_names.each do |name|
-      Card.expire name
-    end
-  end
-end
-
-event :expire_related_names, before: :expire_related, changed: :name do
-  # FIXME: look for opportunities to avoid instantiating the following
-  descendants.each(&:expire)
-  name_referers.each(&:expire)
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/update_read_rules.rb ~~
-end;end;end;end;

data/tmpsets/set/mod011-machines/abstract/machine.rb

@@ -1,277 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class Abstract; module Machine; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine.rb ~~
-# ## What are Machines?
-# {Machine} and {MachineInput} together implement a kind of observer pattern.
-# {Machine} processes a collection of input cards to generate an output card
-# (a {Set::Type::File} card by default). If one of the input cards is changed
-# the output card will be updated.
-#
-# The classic example: A style card observes a collection of css and sccs card
-# to generate a file card with a css file that contains the assembled
-# compressed  css.
-#
-# ## Using Machines
-# Include the Machine module in the card set that is supposed to produce the
-# output card. If the output card should be automatically updated when a input
-# card is changed the input card has to be in a set that includes the
-# MachineInput module.
-#
-# The default machine:
-#
-#  -  uses its item cards as input cards or the card itself if there are no
-# item cards;
-#  -  can be changed by passing a block to collect_input_cards
-#  -  takes the raw view of the input cards to generate the output;
-#  -  can be changed by passing a block to machine_input (in the input card
-# set)
-#  -  stores the output as a .txt file in the '+machine output' card;
-#  -  can be changed by passing a filetype and/or a block to
-#     store_machine_output
-#
-#
-# ## How does it work?
-# Machine cards have a '+machine input' and a '+machine output' card. The
-# '+machine input' card is a pointer to all input cards. Including the
-# MachineInput module creates an 'on: save' event that runs the machines of
-# all cards that are linked to that card via the +machine input pointer.
-module MachineClassMethods
-  attr_accessor :output_config
-
-  def collect_input_cards &block
-    define_method :engine_input, &block
-  end
-
-  def prepare_machine_input &block
-    define_method :before_engine, &block
-  end
-
-  def machine_engine &block
-    define_method :engine, &block
-  end
-
-  def store_machine_output args={}, &block
-    output_config.merge!(args)
-    return unless block_given?
-    define_method :after_engine, &block
-  end
-end
-
-class << self
-  def included host_class
-    host_class.extend(MachineClassMethods)
-    host_class.output_config = { filetype: "txt" }
-
-    # for compatibility with old migrations
-    return unless  Codename[:machine_output]
-
-    host_class.card_accessor :machine_output, type: :file
-    host_class.card_accessor :machine_input, type: :pointer
-
-    set_default_machine_behaviour host_class
-    define_machine_views host_class
-    define_machine_events host_class
-  end
-
-  def define_machine_events host_class
-    event_suffix = host_class.name.tr ":", "_"
-    event_name = "reset_machine_output_#{event_suffix}".to_sym
-    host_class.event event_name, after: :expire_related, on: :save do
-      reset_machine_output
-    end
-  end
-
-  def define_machine_views host_class
-    host_class.format do
-      view :machine_output_url do |_args|
-        machine_output_url
-      end
-    end
-  end
-
-  def set_default_machine_behaviour host_class
-    set_default_input_collection_method host_class
-    set_default_input_preparation_method host_class
-    set_default_output_storage_method host_class
-    host_class.machine_engine { |input| input }
-  end
-
-  def set_default_input_preparation_method host_class
-    host_class.prepare_machine_input {}
-  end
-
-  def set_default_output_storage_method host_class
-    host_class.store_machine_output do |output|
-      filetype = host_class.output_config[:filetype]
-      file = Tempfile.new [id.to_s, ".#{filetype}"]
-      file.write output
-      file.rewind
-      Card::Auth.as_bot do
-        p = machine_output_card
-        p.file = file
-        p.save!
-      end
-      file.close
-      file.unlink
-    end
-  end
-
-  def set_default_input_collection_method host_class
-    host_class.collect_input_cards do
-      # traverse through all levels of pointers and
-      # collect all item cards as input
-      items = [self]
-      new_input = []
-      already_extended = {} # avoid loops
-      loop_limit = 5
-      until items.empty?
-        item = items.shift
-        next if item.trash || already_extended[item.id].to_i > loop_limit
-        if item.item_cards == [item] # no pointer card
-          new_input << item
-        else
-          # item_cards instantiates non-existing cards
-          # we don't want those
-          items.insert(0, item.item_cards.reject(&:unknown?))
-          items.flatten!
-
-          new_input << item if item != self && item.known?
-          already_extended[item] = already_extended[item].to_i + 1
-        end
-      end
-      new_input
-    end
-  end
-end
-
-def run_machine joint="\n"
-  before_engine
-  output =
-    input_item_cards.map do |input_card|
-      run_engine input_card
-    end.select(&:present?).join(joint)
-  after_engine output
-end
-
-def run_engine input_card
-  return if input_card.is_a? Card::Set::Type::Pointer
-  if (cached = fetch_cache_card(input_card))
-    return cached.content
-  end
-
-  input = if input_card.respond_to? :machine_input
-            input_card.machine_input
-          else
-            input_card.format._render_raw
-          end
-  output = engine(input)
-  cache_output_part input_card, output
-  output
-end
-
-def fetch_cache_card input_card, new=nil
-  new &&= { type_id: PlainTextID }
-  Card.fetch input_card.name, name, :machine_cache, new: new
-end
-
-def cache_output_part input_card, output
-  Auth.as_bot do
-    cache_card = fetch_cache_card(input_card, true)
-    cache_card.update_attributes! content: output
-  end
-end
-
-def reset_machine_output
-  Auth.as_bot do
-    (moc = machine_output_card) && moc.real? && moc.delete!
-    update_input_card
-  end
-end
-
-def update_machine_output
-  lock do
-    update_input_card
-    run_machine
-  end
-end
-
-def make_machine_output_coded mod=:machines
-  update_machine_output
-  Auth.as_bot do
-    output_codename =
-      machine_output_card.cardname.parts.map do |part|
-        Card[part].codename || Card[part].cardname.safe_key
-      end.join '_'
-    machine_output_card.update_attributes! codename: output_codename,
-                                           storage_type: :coded,
-                                           mod: mod
-  end
-end
-
-def regenerate_machine_output
-  lock do
-    run_machine
-  end
-end
-
-def lock
-  if ok?(:read) && !(was_already_locked = locked?)
-    Auth.as_bot do
-      lock!
-      yield
-    end
-  end
-ensure
-  unlock! unless was_already_locked
-end
-
-def lock_cache_key
-  "UPDATE-LOCK:#{key}"
-end
-
-def locked?
-  Card.cache.read lock_cache_key
-end
-
-def lock!
-  Card.cache.write lock_cache_key, true
-end
-
-def unlock!
-  Card.cache.write lock_cache_key, false
-end
-
-def update_input_card
-  if DirectorRegister.running_act?
-    input_card = attach_subcard! machine_input_card
-    input_card.content = ""
-    engine_input.each { |input| input_card << input }
-  else
-    machine_input_card.items = engine_input
-  end
-end
-
-def input_item_cards
-  machine_input_card.item_cards
-end
-
-def machine_output_url
-  ensure_machine_output
-  machine_output_card.file.url # (:default, timestamp: false)
-  # to get rid of additional number in url
-end
-
-def machine_output_path
-  ensure_machine_output
-  machine_output_card.file.path
-end
-
-def ensure_machine_output
-  output = fetch trait: :machine_output
-  return if output && output.selected_content_action_id
-  update_machine_output
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine.rb ~~
-end;end;end;end;