card 1.105.6 → 1.107.0

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

@@ -1,148 +1,61 @@
-def run_card_migration core_or_deck
-  prepare_migration
-  verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-  Cardio::Schema.migrate core_or_deck, version, verbose
-end
-
-def prepare_migration
-  Card::Cache.reset_all
-  ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
-  Card::Cache.reset_all
-  Card.config.action_mailer.perform_deliveries = false
-  Card.reset_column_information
-  # this is needed in production mode to insure core db
-  Card::Reference.reset_column_information
-  # structures are loaded before schema_mode is set
-end
-
-# @param mod [Boolean] if true reset column information for models defined in
-#   in mods in the deck
-def reset_column_information mod=false
-  Rails.application.eager_load!
-  load_mod_lib if mod && !ENV["NO_CARD_LOAD"]
-  Cardio::Record.descendants.each(&:reset_column_information)
-end
-
-# FIXME: too general
-# intent is to find Record classes; this gets a lot more.
-def load_mod_lib
-  Dir.glob(Cardio.root.join("mod/*/lib/*.rb")).sort.each { |x| require x }
-end
-
-def without_dumping
-  ActiveRecord::Base.dump_schema_after_migration = false
-  yield
-end
 
 namespace :card do
   desc "migrate structure and cards"
   task migrate: :environment do
     ENV["NO_RAILS_CACHE"] = "true"
-    ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
-
-    stamp = ENV["STAMP_MIGRATIONS"]
-
-    puts "migrating structure"
-    Rake::Task["card:migrate:structure"].invoke
-    Rake::Task["card:migrate:stamp"].invoke :structure if stamp
-
-    puts "migrating deck structure"
-    Rake::Task["card:migrate:deck_structure"].execute
-    if stamp
-      Rake::Task["card:migrate:stamp"].reenable
-      Rake::Task["card:migrate:stamp"].invoke :core_cards
-    end
-
-    puts "migrating core cards"
-    Card::Cache.reset_all
-    # not invoke because we don't want to reload environment
-    Rake::Task["card:migrate:core_cards"].execute
-    if stamp
-      Rake::Task["card:migrate:stamp"].reenable
-      Rake::Task["card:migrate:stamp"].invoke :core_cards
-    end
-
-    puts "migrating deck cards"
-    # not invoke because we don't want to reload environment
-    Rake::Task["card:migrate:deck_cards"].execute
-    if stamp
-      Rake::Task["card:migrate:stamp"].reenable
-      Rake::Task["card:migrate:stamp"].invoke :deck_cards
-    end
 
+    Rake::Task["card:migrate:schema"].invoke
+    Rake::Task["card:migrate:transform"].execute
     Card::Cache.reset_all
   end
 
   namespace :migrate do
-    desc "migrate cards"
-    task cards: %i[core_cards deck_cards]
+    desc "run structure migrations"
+    task schema: :environment do
+      puts "running schema migrations"
 
-    desc "migrate structure"
-    task structure: :environment do
-      ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
+      interpret_env_schema
       without_dumping do
-        Cardio::Schema.migrate :structure, version
+        run_migration :schema
       end
-    end
-
-    desc "migrate core cards"
-    task core_cards: :environment do
-      without_dumping do
-        require "cardio/migration/core"
-        run_card_migration :core_cards
-      end
-    end
-
-    desc "migrate deck structure"
-    task deck_structure: :environment do
-      migrate_deck_structure
-      reset_column_information
-    end
-
-    def migrate_deck_structure
-      require "cardio/migration/deck_structure"
-      set_schema_path
-      Cardio::Schema.migrate :deck, version
       Rake::Task["db:_dump"].invoke # write schema.rb
       reset_column_information true
     end
 
-    def set_schema_path
-      schema_dir = "#{Cardio.root}/db"
-      Dir.mkdir schema_dir unless Dir.exist? schema_dir
-      ENV["SCHEMA"] = "#{schema_dir}/schema.rb"
-    end
+    desc "run transform migrations"
+    task transform: :environment do
+      puts "running transform migrations"
 
-    desc "migrate deck cards"
-    task deck_cards: :environment do
-      require "cardio/migration"
-      run_card_migration :deck_cards
+      without_dumping do
+        prepare_migration
+        run_migration :transform
+      end
     end
 
-    desc "Redo the deck cards migration given by VERSION."
+    desc "Redo the transform migration given by VERSION."
     task redo: :environment do
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
-      verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-      raise "VERSION is required" unless version
+      raise "VERSION is required" unless version.present?
 
       ActiveRecord::Migration.verbose = verbose
       ActiveRecord::SchemaMigration.where(version: version.to_s).delete_all
-      Cardio::Schema.migrate :deck_cards, version
+      run_migration :transform
     end
 
-    # maybe we should move this to a method?
     desc "write the version to a file (not usually called directly)"
     task :stamp, [:type] => [:environment] do |_t, args|
-      ENV["SCHEMA"] ||= "#{Cardio.gem_root}/db/schema.rb"
+      interpret_env_schema
       Cardio.config.action_mailer.perform_deliveries = false
+      Cardio::Migration.new_for(args[:type]).stamp
+    end
 
-      stamp_file = Cardio::Schema.stamp_path args[:type]
+    task port: :environment do
+      Cardio::Migration.port_all
+    end
 
-      Cardio::Schema.mode args[:type] do
-        version = ActiveRecord::Migrator.current_version
-        if version.to_i.positive? && (file = ::File.open(stamp_file, "w"))
-          puts ">>  writing version: #{version} to #{stamp_file}"
-          file.puts version
+    task recode: :environment do
+      Cardio::Mod.dirs.subpaths("data", "recode.yml").each_value do |path|
+        YAML.load_file(path).each do |oldcode, newcode|
+          Card::Codename.recode oldcode, newcode
         end
       end
     end
@@ -152,3 +65,55 @@ namespace :card do
     end
   end
 end
+
+private
+
+def interpret_env_schema schema_dir=nil
+  schema_dir ||= "#{Cardio.root}/db"
+  # schema_dir = "#{Cardio.root}/db"
+  # Dir.mkdir schema_dir unless Dir.exist? schema_dir
+  ENV["SCHEMA"] ||= "#{schema_dir}/schema.rb"
+end
+
+def run_migration type
+  verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+  Cardio::Migration.new_for(type).run version, verbose
+  stamp_migration type
+end
+
+def stamp_migration type
+  return unless ENV["STAMP_MIGRATIONS"]
+
+  task = Rake::Task["card:migrate:stamp"]
+  task.reenable
+  task.invoke type
+end
+
+def prepare_migration
+  interpret_env_schema
+  Card::Cache.reset_all
+  Card.config.action_mailer.perform_deliveries = false
+  Card.reset_column_information
+  # this is needed in production mode to insure core db
+  Card::Reference.reset_column_information
+  # structures are loaded before schema_mode is set
+end
+
+# @param mod [Boolean] if true reset column information for models defined in
+#   in mods in the deck
+def reset_column_information mod=false
+  Rails.application.eager_load!
+  load_mod_lib if mod && !ENV["NO_CARD_LOAD"]
+  Cardio::Record.descendants.each(&:reset_column_information)
+end
+
+# FIXME: too general
+# intent is to find Record classes; this gets a lot more.
+def load_mod_lib
+  Dir.glob(Cardio.root.join("mod/*/lib/*.rb")).sort.each { |x| require x }
+end
+
+def without_dumping
+  ActiveRecord::Base.dump_schema_after_migration = false
+  yield
+end

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

@@ -45,7 +45,7 @@ namespace :card do
       ENV["CARD_UPDATE_SEED"] = "true"
       # tells Cardio::Seed to use fixtures upon which the seeds being updated depend
 
-      invoke_card_tasks %w[reset_tmp seed:replant]
+      invoke_card_tasks %w[reset seed:replant]
     end
 
     def invoke_card_tasks tasks

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

@@ -4,19 +4,19 @@ 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]
+  # task setup: %w[db:setup card:update] # can't do update yet, because it overrides
+  # coded assets, which breaks testing
 
   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,
+      ["migrate:port", "migrate:schema", "migrate:recode", :eat, "migrate:transform",
+       :reset,
        "mod:uninstall", "mod:install", "mod:symlink"].each do |task|
-        # x.report(task) do
         Rake::Task["card:#{task}"].invoke
-        # end
       end
-      # end
     end
   end
 
@@ -24,15 +24,26 @@ namespace :card do
   task eat: :environment do
     parse_options :eat do
       add_opt :m, :mod, "only eat cards in given mod"
-      add_opt :n, :name, "only eat card with name"
-      # FIXME: - name seems not to work, especially in combination with other options
-
-      add_opt :u, :user, "user to credit unless specified (otherwise uses Decko Bot)"
+      add_opt :n, :name, "only eat card with name (handles : for codenames)"
+      add_opt :u, :user, "user to credit unless specified (default is Decko Bot)"
       add_opt :p, :podtype, "pod type: real, test, or all " \
                             "(defaults to all in test env, otherwise real)"
+      add_opt :e, :env, "environment (test, production, etc)"
       flag_opt :v, :verbose, "output progress info and error backtraces"
     end
-    rake_result(:eat) { Cardio::Mod::Eat.new(**options).up }
+
+    adjust_environment options, :eat do
+      rake_result(:eat) { Cardio::Mod::Eat.new(**options).up }
+    end
+  end
+
+  def adjust_environment options, task
+    if (env = options.delete(:env))
+      task_options = options.map { |k, v| "--#{k}=#{v}" }.join(" ")
+      system "env RAILS_ENV=#{env} bundle exec rake card:#{task} #{task_options}"
+    else
+      yield
+    end
   end
 
   desc "Exports card data to mod yaml"
@@ -42,30 +53,25 @@ namespace :card do
       flag_opt :i, :items, "also export card items (with -n)"
       flag_opt :o, :only_items, "only export card items (with -n)", items: :only
       add_opt :c, :cql, "export cards found by CQL (in JSON format)"
+      add_opt_without_shortcut :url, "source card details from url"
       add_opt :m, :mod, "output yaml file in mod"
       add_opt :p, :podtype, "podtype to dump (real or test. default based on current env)"
       add_opt :t, :field_tags, "comma-separated list of field tag marks"
+      add_opt :e, :env, "environment (test, production, etc)"
+    end
+    adjust_environment options, :sow do
+      rake_result(:sow) { Cardio::Mod::Sow.new(**options).out }
     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
+  desc "Clears both cache and tmpfiles"
+  task reset: :environment do
+    parse_options :reset do
+      flag_opt :c, :cache, "cache only"
+      flag_opt :t, :tmpfiles, "tmpfiles only"
     end
+    reset_tmpfiles unless options[:cache]
+    Card::Cache.reset_all unless options[:tmpfiles]
   end
 
   desc "Loads seed data"
@@ -91,17 +97,27 @@ namespace :card do
   end
 
   def add_opt letter, key, desc
-    op.on "-#{letter}", "--#{key.to_s.tr '_', '-'} #{key.to_s.upcase}", desc do |val|
+    op.on "-#{letter}", key_to_option_description(key), desc do |val|
       options[key] = val
     end
   end
 
+  def add_opt_without_shortcut key, desc
+    op.on key_to_option_description(key), desc do |val|
+      options[key] = val
+    end
+  end
+
+  def key_to_option_description key
+    "--#{key.to_s.tr '_', '-'} #{key.to_s.upcase}"
+  end
+
   def op
     @op ||= OptionParser.new
   end
 
   def parse_options task
-    op.banner = "Usage: rake card:#{task} -- [options]"
+    op.banner = "Usage: card #{task} [options]"
     yield if block_given?
     args = op.order!(ARGV) {}
     # args << "-h" if args.empty?
@@ -116,4 +132,17 @@ namespace :card do
     raise "\n>>>>>> FAILURE! #{task} did not complete successfully." \
           "\n>>>>>> Please address errors and re-run:\n\n\n"
   end
+
+  def reset_tmpfiles
+    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
 end

data/mod/core/set/abstract/task_table.rb

@@ -0,0 +1,16 @@
+format :html do
+  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
+
+  def task_table tasks
+    table_content = tasks.map do |task, task_config|
+      task_row task, task_config[:mod]
+    end
+    table table_content, header: %w[Task Description]
+  end
+end

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

@@ -1,5 +1,9 @@
 
 basket[:tasks] = {}
+basket[:config_title] = {
+  basic: "Basic configuration",
+  editor: "Editor configuration"
+}
 # to add an admin task:
 #
 # basket[:tasks][TASK_NAME] = {
@@ -12,3 +16,107 @@ basket[:tasks] = {}
 
 #   MOD_task_TASK_NAME_link_text: LINK_TEXT
 #   MOD_task_TASK_NAME_description: DESCRIPTION
+
+def mod_cards_with_config
+  Card.search(type: :mod).select { |mod| mod.admin_config.present? }
+end
+
+def create_admin_items mod, category, subcategory, values
+  Array.wrap(values).map do |value|
+    ::AdminItem.new(mod, category, subcategory, value).tap do |config|
+      codenamed = Card::Codename.exist? config.codename.to_sym
+      config.roles = codenamed ? Card[config.codename.to_sym].responsible_role : []
+    end
+  end
+end
+
+def scoping_rule_card
+  Card.fetch([self, :self, :update], new: {})
+end
+
+def responsible_role
+  scoping_rule_card.find_existing_rule_card.item_cards.map(&:codename)
+end
+
+def all_configs
+  mod_cards_with_config.map(&:admin_config_objects).flatten
+end
+
+def all_admin_configs_grouped_by property1, property2=nil
+  return admin_config_group_by_properties property1, property2 if property2
+
+  result = Hash.new { |hash, k| hash[k] = [] }
+  all_configs.each_with_object(result) do |config, h|
+    property_values = Array.wrap(config.send(property1))
+    property_values.each do |value|
+      h[value] << config
+    end
+  end
+end
+
+def all_admin_configs_of_category category
+  all_admin_configs_grouped_by(:category)[category]
+end
+
+def config_codenames_grouped_by_title configs
+  configs&.group_by { |c| c.title }&.map do |title, grouped_configs|
+    [title, grouped_configs.map { |config| config.codename.to_sym }]
+  end
+end
+
+format :html do
+  def section title, content
+    "<p>#{section_title(title)}#{content}</p>"
+  end
+
+  def section_title title
+    "<h3>#{title}</h3>"
+  end
+
+  def list_section title, items, item_view=:bar
+    return unless items.present?
+
+    section title, list_section_content(items, item_view)
+  end
+
+  def nested_list_section title, grouped_items
+    output [
+      section_title(title),
+      wrap_with(:div, accordion_sections(grouped_items), class: "accordion")
+    ]
+  end
+
+  def accordion_sections grouped_items
+    return unless grouped_items.present?
+
+    grouped_items.map do |title, codenames|
+      accordion_item(title,
+                     subheader: nil,
+                     body: list_section_content(codenames),
+                     open: false,
+                     context: title.hash)
+    end.join " "
+  end
+
+  def list_section_content items, item_view=:bar
+    items&.map do |card|
+      nest card, view: item_view
+    end&.join(" ")
+  end
+end
+
+private
+
+def admin_config_group_by_properties property1, property2
+  result = Hash.new { |hash, k| hash[k] = Hash.new { |hash2, k2| hash2[k2] = [] } }
+  all_configs.each_with_object(result) do |config, h|
+    property1_values = Array.wrap(config.send(property1))
+    property2_values = Array.wrap(config.send(property2))
+
+    property1_values.each do |p1v|
+      property2_values.each do |p2v|
+        h[p1v][p2v] << config
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+include_set Abstract::TaskTable
+
 basket[:tasks].merge!(
   clear_cache: {
     mod: :core,
@@ -54,18 +56,7 @@ 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")
-    ]
+    task_table basket[:tasks]
   end
 
   view :warning do

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

@@ -0,0 +1,39 @@
+include_set Abstract::List
+
+def item_codenames
+  Cardio.mods.map do |mod|
+    "#{mod}_mod"
+  end
+end
+
+def content
+  item_codenames.map(&:cardname).compact.to_pointer_content
+end
+
+format :html do
+  %i[cardtypes settings tasks configurations].each do |view_name|
+    view view_name do
+      [
+        content_tag(:h1, view_name),
+        card.all_admin_configs_grouped_by(:category, :mod)[view_name.to_s]
+            .map do |(mod, configs)|
+          list_section(mod.name, configs.map { |c| c.codename.to_sym })
+        end.join("<br\>")
+      ]
+    end
+  end
+
+  view :roles do
+    [
+      content_tag(:h1, "Roles"),
+      card.all_admin_configs_grouped_by(:roles, :category).map do |(role, configs_by_cat)|
+        output [
+          content_tag(:h2, Card[role.to_sym].name),
+          (configs_by_cat.map do |(cat, configs)|
+            list_section cat, configs.map(&:codename)
+          end)
+        ]
+      end.join("<br\>")
+    ]
+  end
+end

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

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-def ok_to_read
+def ok_to_read?
   true
 end