card 1.104.1 → 1.105.0

data/mod/core/lib/tasks/card.rake

@@ -0,0 +1,115 @@
+require "optparse"
+
+namespace :card do
+  desc "Creates the database, loads the schema, initializes seed data, " \
+       "and adds symlinks to public directories"
+  task setup: %w[db:setup card:mod:symlink]
+
+  desc "Runs migrations, installs mods, and updates symlinks"
+  task :update do
+    failing_loudly "decko update" do
+      ENV["NO_RAILS_CACHE"] = "true"
+      # Benchmark.bm do |x|
+      [:migrate, :eat, :reset_tmp, :reset_cache,
+       "mod:uninstall", "mod:install", "mod:symlink"].each do |task|
+        # x.report(task) do
+        Rake::Task["card:#{task}"].invoke
+        # end
+      end
+      # end
+    end
+  end
+
+  desc "Ingests card data from mod yaml"
+  task eat: :environment do
+    parse_options :eat do
+      add_opt :m, :mod, "only eat cards in given mod"
+      add_opt :u, :user, "user to credit unless specified (otherwise uses Decko Bot)"
+      add_opt :t, :type, "pod type: real, test, or all"
+      flag_opt :v, :verbose, "output progress info and error backtraces"
+    end
+    rake_result(:eat) { Cardio::Mod::Eat.new(**options).up }
+  end
+
+  desc "Exports card data to mod yaml"
+  task sow: :environment do
+    parse_options :sow do
+      add_opt :n, :name, "export card with name/mark (handles : and ~ prefixes)"
+      flag_opt :i, :items, "also export card items (with -n)"
+      flag_opt :o, :only_items, "also export card items (with -n)", items: :only
+      add_opt :c, :cql, "export cards found by CQL (in JSON format)"
+      add_opt :m, :mod, "output yaml to data/environment.yml file in mod"
+      add_opt :e, :env, "environment to dump to (default is current env)"
+      add_opt :t, :field_tags, "comma-separated list of field tag marks"
+    end
+    rake_result(:sow) { Cardio::Mod::Sow.new(**options).out }
+  end
+
+  desc "Resets cache"
+  task reset_cache: :environment do
+    Card::Cache.reset_all
+  end
+
+  desc "reset with an empty tmp directory"
+  task :reset_tmp do
+    tmp_dir = Cardio.paths["tmp"].first
+    if Cardio.paths["tmp"].existent
+      Dir.foreach(tmp_dir) do |filename|
+        next if filename.match?(/^\./)
+
+        FileUtils.rm_rf File.join(tmp_dir, filename), secure: true
+      end
+    else
+      Dir.mkdir tmp_dir
+    end
+  end
+
+  desc "Loads seed data"
+  task seed: ["db:seed"]
+
+  def options
+    @options ||= {}
+  end
+
+  def rake_result task
+    result = yield
+    if result == :success
+      exit 0 if @options.present? # otherwise rake tries to run the arguments as tasks
+    else
+      puts "ERROR in card #{task}:\n  #{result}".red
+      exit 1
+    end
+  end
+
+  def flag_opt letter, key, desc, hash=nil
+    hash ||= { key => true }
+    op.on("-#{letter}", "--#{key.to_s.tr '_', '-'}", desc) { options.merge! hash }
+  end
+
+  def add_opt letter, key, desc
+    op.on "-#{letter}", "--#{key.to_s.tr '_', '-'} #{key.to_s.upcase}", desc do |val|
+      options[key] = val
+    end
+  end
+
+  def op
+    @op ||= OptionParser.new
+  end
+
+  def parse_options task
+    op.banner = "Usage: rake card:#{task} -- [options]"
+    yield if block_given?
+    args = op.order!(ARGV) {}
+    # args << "-h" if args.empty?
+    op.parse! args
+  end
+
+  def failing_loudly task
+    yield
+  rescue StandardError
+    # TODO: fix this so that message appears *after* the errors.
+    # Solution should ensure that rake still exits with error code 1!
+    raise "\n>>>>>> FAILURE! #{task} did not complete successfully." \
+          "\n>>>>>> Please address errors and re-run:\n\n\n"
+  end
+end

data/mod/core/locales/de.yml

@@ -26,3 +26,7 @@ de:
   core_rename_confirm: "Sind Sie sicher, dass Sie die Karte umbenennen wollen?"
   skip_update_referer_content:
     Verweise auf diesen Namen nicht aktualisieren
+
+  core_admin_warn: Administrator Warnung
+  core_admin_email_off:
+    E-Mail-Versand ist ausgeschaltet. Ändere die Einstellungen in %{path}, damit Benachrichtigungen verschickt werden, wenn sich neue Nutzer registrieren.

data/mod/core/locales/en.yml

@@ -25,5 +25,18 @@ en:
   core_rename: "Rename"
   core_rename_confirm: "Are you sure you want to rename?"
 
+  core_task_clear_cache_link_text: "Clear Cache"
+  core_task_clear_cache_description: "Clear Cache!"
+
+  core_task_empty_trash_link_text: "Empty Trash"
+  core_task_empty_trash_description: "Empty Trash!"
+
+  core_task_regenerate_assets_link_text: "Regenerate Assets"
+  core_task_regenerate_assets_description: "Regen!"
+
+  core_admin_warn: Administrator Warning
+  core_admin_email_off:
+    Email delivery is turned off. Change settings in %{path} to send sign up notifications.
+
   skip_update_referer_content:
     do not update references to this name

data/mod/core/set/all/admin.rb

@@ -0,0 +1,14 @@
+
+basket[:tasks] = {}
+# to add an admin task:
+#
+# basket[:tasks][TASK_NAME] = {
+#   irreversible: TRUE/FALSE,
+#   execute_policy: -> { TASK_CODE },
+#   mod: MODNAME
+# }
+#
+# Then add two lines in the locales containing the link text and the description:
+
+#   MOD_task_TASK_NAME_link_text: LINK_TEXT
+#   MOD_task_TASK_NAME_description: DESCRIPTION

data/mod/core/set/all/codename.rb

@@ -2,6 +2,10 @@ def codename
   super&.to_sym
 end
 
+def codename?
+  codename.present?
+end
+
 event :validate_codename, :validate, on: :update, changed: :codename do
   validate_codename_permission
   validate_codename_uniqueness

data/mod/core/set/all/content.rb

@@ -9,10 +9,9 @@ event :save_draft, :store, on: :update, when: :draft? do
   abort :success
 end
 
-event :set_default_content,
-      :prepare_to_validate,
+event :set_default_content, :prepare_to_validate,
       on: :create, when: :use_default_content? do
-  self.db_content = template.db_content
+  self.db_content = default_content
 end
 
 def draft?
@@ -23,8 +22,13 @@ def clean_html?
   true
 end
 
+# TODO: let default_content in card_accessor override template
+def default_content
+  template&.db_content
+end
+
 def use_default_content?
-  !db_content_changed? && template && template.db_content.present?
+  !db_content_changed? && default_content.present?
 end
 
 def unfilled?

data/mod/core/set/all/{abort.rb → result.rb}

@@ -1,3 +1,12 @@
+event :notable_exception_raised do
+  error = Card::Error.current
+  Rails.logger.debug "#{error.message}\n#{error.backtrace * "\n  "}"
+end
+
+def success
+  Env.success name
+end
+
 # The Card#abort method is for cleanly exiting an action without continuing
 # to process any further events.
 #
@@ -42,10 +51,10 @@ end
 
 def abort_success
   if @supercard
-    @supercard.subcards.delete key
+    @supercard.subcards.remove key
     @supercard.director.subdirectors.delete self
-    expire :soft
   end
+  expire :soft
   true
 end
 
@@ -61,16 +70,3 @@ def with_transaction_returning_status &block
   end
   status
 end
-
-# FIXME: these two do not belong here!
-
-public
-
-event :notable_exception_raised do
-  error = Card::Error.current
-  Rails.logger.debug "#{error.message}\n#{error.backtrace * "\n  "}"
-end
-
-def success
-  Env.success(name)
-end

data/mod/core/set/all/states.rb

@@ -74,9 +74,23 @@ end
 alias_method :new_card?, :new?
 alias_method :unreal?, :new?
 
+def purity
+  case
+  when new?      then :new
+  when pristine? then :pristine
+  else                :altered
+  end
+end
+
 # has not been edited directly by human users.  bleep blorp.
 def pristine?
-  new_card? || !user_changes?
+  new_card? ||
+    (created_at == updated_at && creator_id == WagnBotID) ||
+    !user_changes?
+end
+
+def altered?
+  !pristine?
 end
 
 def user_changes?

data/mod/core/set/all/trash.rb

@@ -1,55 +1,9 @@
-basket[:tasks] << {
-  name: :empty_trash,
+basket[:tasks][:empty_trash] = {
+  mod: :core,
   irreversible: true,
-  execute_policy: -> { Card.empty_trash },
-  stats: {
-    title: "trashed cards",
-    count: -> { Card.where(trash: true) },
-    link_text: "empty trash",
-    task: "empty_trash"
-  }
+  execute_policy: -> { Cardio::Utils.empty_trash }
 }
 
-module ClassMethods
-  def empty_trash
-    Card.delete_trashed_files
-    Card.where(trash: true).in_batches.update_all(left_id: nil, right_id: nil)
-    Card.where(trash: true).in_batches.delete_all
-    Card::Action.delete_cardless
-    Card::Change.delete_actionless
-    Card::Act.delete_actionless
-    Card::Reference.clean
-  end
-
-  # deletes any file not associated with a real card.
-  def delete_trashed_files
-    dir = Cardio.paths["files"].existent.first
-    # TODO: handle cloud files
-    return unless dir
-
-    (all_trashed_card_ids & all_file_ids).each do |file_id|
-      delete_files_with_id dir, file_id
-    end
-  end
-
-  def delete_files_with_id dir, file_id
-    raise Card::Error, t(:core_exception_almost_deleted) if Card.exists?(file_id)
-
-    ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
-  end
-
-  def all_file_ids
-    dir = Card.paths["files"].existent.first
-    Dir.entries(dir)[2..-1].map(&:to_i)
-  end
-
-  def all_trashed_card_ids
-    trashed_card_sql = %( select id from cards where trash is true )
-    sql_results = Card.connection.select_all(trashed_card_sql)
-    sql_results.map(&:values).flatten.map(&:to_i)
-  end
-end
-
 def trash?
   trash
 end
@@ -66,35 +20,12 @@ def delete! args={}
   end
 end
 
-def add_to_trash args
-  return if new_card?
-
-  yield args.merge trash: true
-end
-
 event :manage_trash, :prepare_to_store, on: :create do
   pull_from_trash!
   self.trash = false
   true
 end
 
-def pull_from_trash!
-  return unless (id = Card::Lexicon.id key) # name is already known
-  return unless (trashed_card = Card.where(id: id).take)&.trash
-
-  # confirm name is actually in trash
-
-  db_attributes["id"] = trashed_card.db_attributes["id"]
-  # id_in_database returns existing card id
-
-  @from_trash = true
-  @new_record = false
-end
-
-def db_attributes
-  send(:mutations_from_database).send :attributes
-end
-
 event :validate_delete, :validate, on: :delete do
   unless codename.blank?
     errors.add :delete, t(:core_error_system_card, name: name, codename: codename)
@@ -112,7 +43,7 @@ event :validate_delete, :validate, on: :delete do
   errors.add :delete, t(:core_error_user_edits, name: name) if account && has_edits?
 end
 
-event :validate_delete_children, after: :validate_delete, on: :delete do
+event :delete_children, after: :validate_delete, on: :delete do
   return if errors.any?
 
   each_child do |child|
@@ -125,6 +56,27 @@ event :validate_delete_children, after: :validate_delete, on: :delete do
   end
 end
 
+def pull_from_trash!
+  return unless (id = Card::Lexicon.id key) # name is already known
+  return unless (trashed_card = Card.where(id: id).take)&.trash
+
+  # confirm name is actually in trash
+
+  db_attributes["id"] = trashed_card.db_attributes["id"]
+  # id_in_database returns existing card id
+
+  @from_trash = true
+  @new_record = false
+end
+
+def add_to_trash args
+  yield args.merge(trash: true) unless new_card?
+end
+
+def db_attributes
+  send(:mutations_from_database).send :attributes
+end
+
 def delete_as_subcard subcard
   subcard.trash = true
   subcard subcard

data/mod/core/set/all/type.rb

@@ -5,7 +5,7 @@ module ClassMethods
 end
 
 event :validate_type_change, :validate, on: :update, changed: :type_id do
-  return unless (c = dup) && c.action == :create && !c.valid?
+  return unless (c = dup) && (c.action == :create) && !c.valid?
 
   errors.add :type, t(:core_error_cant_change_errors,
                       name: name,
@@ -67,7 +67,7 @@ end
 def type_id_from_code
   return if simple?
   each_type_assigning_module_key do |module_key|
-    type_id = Card::Set::Type.assignment[module_key]
+    type_id = Card::Set::Type.assignment[module_key]&.card_id
     return type_id if type_id
   end
   nil

data/mod/core/set/all/utils.rb

@@ -1,95 +1,11 @@
-module ClassMethods
-  def merge_list attribs, opts={}
-    unmerged = []
-    attribs.each do |row|
-      if merge row["name"], row, opts
-        Rails.logger.info "merged #{row['name']}"
-      else
-        unmerged.push row
-      end
-    end
 
-    if unmerged.empty?
-      Rails.logger.info "successfully merged all!"
-    else
-      unmerged_json = JSON.pretty_generate unmerged
-      report_unmerged_json unmerged_json, opts[:output_file]
-    end
-    unmerged
-  end
-
-  def report_unmerged_json unmerged_json, output_file
-    if output_file
-      ::File.open output_file, "w" do |f|
-        f.write unmerged_json
-      end
-    else
-      Rails.logger.info "failed to merge:\n\n#{unmerged_json}"
-    end
-  end
-
-  def merge name, attribs={}, opts={}
-    # puts "merging #{name}"
-    card = fetch name, new: {}
-    return unless mergeable? card, opts[:pristine]
-
-    resolve_file_attributes! attribs
-    card.safe_update! attribs
-  end
-
-  private
-
-  def resolve_file_attributes! attribs
-    %i[image file].each do |attach|
-      next unless attribs[attach].is_a?(String)
-
-      attribs[attach] = ::File.open(attribs[attach])
-    end
-  end
-
-  def mergeable? card, pristine_only
-    return true unless pristine_only
-
-    !card.pristine?
-  end
-end
-
-# separate name and other attributes
-def safe_update! attribs
-  separate_name_update! attribs.delete("name") unless new?
-  update! attribs if attribs.present?
-end
-
-def separate_name_update! new_name
-  return if new_name.to_s == name.to_s
-
-  update! name: new_name
-end
-
-# rubocop:disable Style/GlobalVars
-def measure desc
-  $times ||= {}
-  res = nil
-  t = Benchmark.measure do
-    res = yield
-  end
-  $times[desc] = $times.key?(desc) ? t + $times[desc] : t
-  puts "#{desc}: #{t}".red
-  res
-end
-# rubocop:enable Style/GlobalVars
-
-def mod_root modname
-  if (spec = Gem::Specification.find_by_name "card-mod-#{modname}")
-    spec.full_gem_path
-  else
-    "#{Cardio.gem_root}/mod/#{modname}"
-  end
+def mod_path modname
+  Cardio::Mod.dirs.path modname
 end
 
 delegate :t, to: ::I18n
 
 format do
   delegate :t, to: ::I18n
-  delegate :measure, to: :card
+  delegate :mod_path, to: :card
 end

data/mod/core/set/right/autoname.rb

@@ -1,3 +1,5 @@
+assign_type :phrase
+
 def history?
   false
 end

data/mod/core/set/self/admin/warning_alert.haml

@@ -0,0 +1,3 @@
+%h5
+  = t :core_admin_warn
+= list_tag warnings

data/mod/core/set/self/admin.rb

@@ -0,0 +1,173 @@
+basket[:tasks].merge!(
+  clear_cache: {
+    mod: :core,
+    execute_policy: -> { Card::Cache.reset_all }
+  },
+  regenerate_assets: {
+    mod: :core,
+    execute_policy: -> { Card::Assets.refresh force: true }
+  }
+)
+
+basket[:warnings] = [:no_email_delivery]
+# For each warning in the basket (eg :my_warning), the core view
+# will run a test by appending a question mark (eg #my_warning?).
+# If it fails it will generate a message by appending message
+# (eg #my_warning_message).
+
+def no_email_delivery?
+  Card.config.action_mailer.perform_deliveries == false
+end
+
+event :admin_tasks, :initialize, on: :update do
+  return unless (task = Env.params[:task]&.to_sym) && (task_config = basket[:tasks][task])
+  raise Card::Error::PermissionDenied, self unless Auth.always_ok?
+
+  # when :repair_references    then Card::Reference.repair_all
+  # when :repair_permissions   then Card.repair_all_permissions
+  # # when :regenerate_scripts   then Card::Assets.refresh_scripts
+  # when :clear_history
+  #   not_allowed "clear history" unless irreversibles_tasks_allowed?
+  #   Card::Action.delete_old
+
+  run_task_from_task_basket task, task_config
+  abort :success
+end
+
+def run_task_from_task_basket task, task_config
+  if !irreversibles_tasks_allowed? && task_config[:irreversible]
+    not_allowed t("#{task_config[:mod]}_task_#{task}_link_text")
+  else
+    task_config[:execute_policy]&.call
+  end
+end
+
+def not_allowed task
+  raise Card::Error::PermissionDenied,
+        "The admin task '#{task}' is disabled for security reasons.<br>"\
+        "You can enable it with the config option 'allow_irreversible_admin_tasks'"
+end
+
+def irreversibles_tasks_allowed?
+  Cardio.config.allow_irreversible_admin_tasks
+end
+
+format :html do
+  view :core, cache: :never do
+    table_content = basket[:tasks].map do |task, task_config|
+      task_row task, task_config[:mod]
+    end
+    table table_content, header: %w[Task Description]
+  end
+
+  def task_row task, mod
+    base = "#{mod}_task_#{task}"
+    [
+      link_to_card(:admin, t("#{base}_link_text"), path: { action: :update, task: task }),
+      t("#{base}_description")
+    ]
+  end
+
+  view :warning do
+    warnings = basket[:warnings].map do |warning|
+      card.send("#{warning}?") ? send("#{warning}_message") : nil
+    end
+    warnings.compact!
+    warnings.empty? ? "" : warning_alert(warnings)
+  end
+
+  def warning_alert warnings
+    # 'ADMINISTRATOR WARNING'
+    alert(:warning, true) { haml :warning_alert, warnings: warnings }
+  end
+
+  def no_email_delivery_message
+    # "Email delivery is turned off."
+    # "Change settings in config/application.rb to send sign up notifications."
+    t :core_admin_email_off, path: "config/application.rb"
+  end
+
+  # def card_stats
+  #   [
+  #     { title: "cards",
+  #       count: Card.where(trash: false) },
+  #     { title: "actions",
+  #       count: Card::Action },
+  #     #  link_text: "clear history",
+  #     #  task: "clear_history" },
+  #     { title: "references",
+  #       count: Card::Reference }
+  #     # link_text: "repair all",
+  #     # task: "repair_references" }
+  #   ]
+  # end
+
+  # def cache_stats
+  #   [
+  #     { title: "style assets",
+  #       link_text: "regenerate styles and scripts",
+  #       task: "regenerate_assets" } # ,
+  #     # { title: "script assets",
+  #     #   link_text: "regenerate scripts",
+  #     #   task: "regenerate_scripts" }
+  #   ]
+  #   # return stats unless Card.config.view_cache#
+  #   # stats << { title: "view cache",
+  #   #            count: Card::View,
+  #   #            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]
+  #
+  #   res << link_to_card(:admin, (args[:link_text] || args[:task]),
+  #                       path: { action: :update, task: args[:task] })
+  #   res
+  # end
+  #
+  # def count counter
+  #   counter = counter.call if counter.is_a?(Proc)
+  #   counter.respond_to?(:count) ? counter.count : counter
+  # end
+
+  # def asset_input_cache_count
+  #   Card.where(right_id: AssetInputCacheID).count
+  # end
+  #
+  # def delete_sessions_link months
+  #   link_to_card :admin, months, path: { action: :update, months: months,
+  #                                        task: "delete_old_sessions" }
+  # 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