card 1.102.0 → 1.103.3

data/lib/cardio/migration.rb

@@ -28,40 +28,29 @@ module Cardio
       end
 
       def migration_paths mig_type=type
-        Cardio.migration_paths mig_type
-      end
-
-      def schema mig_type=type
-        Cardio.schema mig_type
+        Schema.migration_paths mig_type
       end
 
       def schema_suffix mig_type=type
-        Cardio.schema_suffix mig_type
+        Schema.suffix mig_type
       end
 
-      def schema_mode mig_type=type
-        Cardio.with_suffix mig_type do
-          paths = Cardio.migration_paths(type)
-          yield(paths)
-        end
+      def schema_mode mig_type=type, &block
+        Schema.mode mig_type, &block
       end
 
       def assume_migrated_upto_version
-        schema_mode do
-          ActiveRecord::Schema.assume_migrated_upto_version schema,
-                                                            migration_paths
-        end
+        Schema.assume_migrated_upto_version type
       end
 
       def data_path filename=nil
-        path = migration_paths.first
-        File.join([path, "data", filename].compact)
+        File.join([migration_paths.first, "data", filename].compact)
       end
     end
 
     def contentedly
       Card::Cache.reset_all
-      Cardio.schema_mode "" do
+      Schema.mode "" do
         Card::Auth.as_bot do
           yield
         ensure
@@ -101,7 +90,7 @@ module Cardio
       names_or_keys = Array(names_or_keys)
       Card::Mailer.perform_deliveries = false
 
-      Cardio::Migration::Import.new(data_path).merge only: names_or_keys
+      Migration::Import.new(data_path).merge only: names_or_keys
     end
 
     def merge_pristine_cards names_or_keys
@@ -121,14 +110,6 @@ module Cardio
       self.class.data_path filename
     end
 
-    def schema_mode
-      Cardio.schema_mode self.class.type
-    end
-
-    def migration_paths
-      Cardio.paths self.class.type
-    end
-
     # Execute this migration in the named direction
     # copied from ActiveRecord to wrap 'up' in 'contentendly'
     def exec_migration conn, direction

data/lib/cardio/mod/dirs.rb

@@ -1,5 +1,7 @@
+require "cardio/mod/modfile_loader"
+
 module Cardio
-  module Mod
+  class Mod
     # Dirs objects are used to manage the load paths for card mods.
     # Mods can be loaded as gems and by using directories with mod subdirectories.
     #
@@ -48,8 +50,8 @@ module Cardio
       # @param mod_paths [String, Array<String>] paths to directories that contain mods
       def initialize mod_paths=[]
         @mods = []
+        @mods_by_name = {}
         @loaded_gem_mods = ::Set.new
-        @paths = {}
         mod_paths = Array(mod_paths)
         mod_paths.each do |mp|
           @current_path = mp
@@ -57,45 +59,46 @@ module Cardio
         end
         load_from_gemfile
         super()
-        @mods.each do |mod_name|
-          self << @paths[mod_name]
+        @mods.each do |mod|
+          self << mod.path
         end
       end
 
+      def add_gem_mod mod_name, mod_path
+        return if @loaded_gem_mods.include?(mod_name)
+
+        @loaded_gem_mods << mod_name
+        add_mod mod_name, mod_path
+      end
+
       # Add a mod to mod load paths
-      def add_path mod_name, path=nil
-        if @mods.include? mod_name
-          raise Card::Error,
+      def add_mod mod_name, path=nil
+        if @mods_by_name.key? Mod.normalize_name(mod_name)
+          raise ::Card::Error,
                 "name conflict: mod with name \"#{mod_name}\" already loaded"
         end
-        @mods << mod_name
-        path ||= File.join @current_path, mod_name
-        @paths[mod_name] = path
-      end
-
-      def gem_mod name
-        deps = Mod.dependencies name
-        unknown_gem_mod!(name) if deps.blank?
-        deps.each { |spec| add_gem_mod spec.name, spec.full_gem_path }
-      end
 
-      def unknown_gem_mod! name
-        raise Card::Error, %(Unknown gem "#{name}". Make sure it is in your Gemfile.)
+        path ||= File.join @current_path, mod_name
+        mod = Mod.new mod_name, path, @mods.size
+        @mods << mod
+        @mods_by_name[mod.name] = mod
       end
 
-      def add_gem_mod mod_name, mod_path
-        return if @loaded_gem_mods.include?(mod_name)
-
-        @loaded_gem_mods << mod_name
-        add_path mod_name, mod_path
+      def delete_mod mod_name
+        name = Mod.normalize_name mod_name
+        mod = @mods_by_name[name]
+        @mods.delete mod
+        @mods_by_name.delete name
       end
 
-      alias_method :mod, :add_path
-
       # @param mod_name [String] the name of a mod
       # @return the path to mod `mod_name`
       def path mod_name
-        @paths[mod_name] || @paths["card-mod-#{mod_name}"]
+        fetch_mod(mod_name)&.path
+      end
+
+      def fetch_mod mod_name
+        @mods_by_name[Mod.normalize_name(mod_name)]
       end
 
       # Iterate over each mod directory
@@ -114,22 +117,24 @@ module Cardio
 
       def each_tmp type
         @mods.each do |mod|
-          path = tmp_dir mod, type
+          path = mod.tmp_dir type
           yield path if Dir.exist? path
         end
       end
 
       def each_with_tmp type=nil
         @mods.each do |mod|
-          dirname = dirname @paths[mod], type
-          yield dirname, tmp_dir(mod, type) if Dir.exist? dirname
+          dirname = dirname mod.path, type
+          yield dirname, mod.tmp_dir(type) if Dir.exist? dirname
         end
       end
 
-      def each_assets_path
+      def each_public_path
         @mods.each do |mod|
-          path = File.join(@paths[mod], "public", "assets")
-          yield mod, path if Dir.exist? path
+          path = mod.public_path
+          next unless Dir.exist? path
+
+          yield mod.name, path
         end
       end
 
@@ -139,13 +144,14 @@ module Cardio
         modfile_path = File.join @current_path, "Modfile"
         return unless File.exist? modfile_path
 
-        eval File.read(modfile_path), binding
+        loader = ModfileLoader.new self
+        loader.load modfile_path
         true
       end
 
       def load_from_dir
         Dir.entries(@current_path).sort.each do |filename|
-          add_path filename unless filename.match?(/^\./)
+          add_mod filename unless filename.match?(/^\./)
         end
       end
 
@@ -154,12 +160,6 @@ module Cardio
           add_gem_mod mod_name, mod_spec.full_gem_path
         end
       end
-
-      def tmp_dir modname, type
-        index = @mods.index modname
-        File.join Card.paths["tmp/#{type}"].first,
-                  "mod#{'%03d' % (index + 1)}-#{modname}"
-      end
     end
   end
 end

data/lib/cardio/mod/load_strategy/eval.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # Put everything for the module definition in one string and the evaluate
       # it immediately with ruby's eval method.

data/lib/cardio/mod/load_strategy/pattern_tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # The {TmpFiles} load strategy version for set pattern modules/
       class PatternTmpFiles < TmpFiles

data/lib/cardio/mod/load_strategy/set_binding_magic.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     # Tries to build the module with as little string evaluation as possible.
     # The problem here is that in methods like `module_eval` the Module.nesting
     # list gets lost so all references in mod files to constants in the

data/lib/cardio/mod/load_strategy/set_tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # The {TmpFiles} load strategy version for set modules
       class SetTmpFiles < LoadStrategy::TmpFiles
@@ -21,13 +21,19 @@ module Cardio
         end
 
         def load_tmp_files
-          mod_dirs.each_tmp(:set) do |set_tmp_dir|
-            Card::Set::Pattern.codes.each do |pattern|
-              pattern_dir = "#{set_tmp_dir}/#{pattern}"
-              Loader.load_dir "#{pattern_dir}/**" if Dir.exist? pattern_dir
+          pattern_groups.each do |pattern_group|
+            mod_dirs.each_tmp(:set) do |set_tmp_dir|
+              load_tmp_files_for_pattern pattern_group, set_tmp_dir
             end
           end
         end
+
+        def load_tmp_files_for_pattern pattern_group, set_tmp_dir
+          pattern_group.each do |pattern|
+            pattern_dir = "#{set_tmp_dir}/#{pattern}"
+            Loader.load_dir "#{pattern_dir}/**" if Dir.exist? pattern_dir
+          end
+        end
       end
     end
   end

data/lib/cardio/mod/load_strategy/tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # LoadStrategy for mod modules. It writes the code to tmp files
       # and then loads the tmp files. (deprecated)

data/lib/cardio/mod/load_strategy.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     # Shared code for the three different load strategies: Eval, TmpFiles and BindingMagic
     class LoadStrategy
       class << self
@@ -14,9 +14,7 @@ module Cardio
         end
 
         def class_for_set_pattern strategy
-          return PatternTmpFiles if strategy == :tmp_files
-
-          Eval
+          strategy == :tmp_files ? PatternTmpFiles : Eval
         end
 
         def tmp_files?
@@ -25,7 +23,8 @@ module Cardio
       end
 
       attr_reader :loader
-      delegate :template_class, :each_file, :mod_dirs, :parts_from_path, to: :loader
+      delegate :template_class, :pattern_groups, :each_file, :mod_dirs, :parts_from_path,
+               to: :loader
 
       def initialize loader
         LoadStrategy.current = self.class

data/lib/cardio/mod/loader/set_loader.rb

@@ -1,14 +1,10 @@
 module Cardio
-  module Mod
+  class Mod
     class Loader
       # A SetLoader object loads all set modules for a list of mods.
       # The mods are given by a Mod::Dirs object.
       # SetLoader can use three different strategies to load the set modules.
       class SetLoader < Loader
-        def template_class
-          SetTemplate
-        end
-
         def initialize args={}
           @no_all = args.delete :no_all
           super load_strategy: args[:load_strategy], mod_dirs: args[:mod_dirs]
@@ -20,22 +16,26 @@ module Cardio
 
         def load
           super
-          # Card::Set.process_base_modules
-          Card::Set.clean_empty_modules
+          Card::Set.finalize_load
         end
 
-        # does not include abstract
-        def main_patterns
-          method = @no_all ? :nonbase_codes : :codes
-          Card::Set::Pattern.send method
+        def template_class
+          SetTemplate
         end
 
         def each_file &block
-          # each_file_with_patterns :abstract, &block
-          each_file_with_patterns(*main_patterns, &block)
+          pattern_groups.each do |pattern_group|
+            each_file_with_patterns pattern_group, &block
+          end
         end
 
-        def each_file_with_patterns *patterns, &block
+        def pattern_groups
+          Card::Set::Pattern.grouped_codes with_all: !@no_all
+        end
+
+        private
+
+        def each_file_with_patterns patterns, &block
           each_mod_dir :set do |base_dir|
             patterns.each do |pattern|
               each_file_in_dir base_dir, pattern.to_s, &block

data/lib/cardio/mod/loader/set_pattern_loader.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class Loader
       class SetPatternLoader < Loader
         def template_class

data/lib/cardio/mod/loader/set_template.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class Loader
       # Template for set modules
       class SetTemplate < ModuleTemplate

data/lib/cardio/mod/loader.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 module Cardio
-  module Mod
+  class Mod
     # Cardio::Mod::Loader is used to load all part of a mod,
     # i.e. initializers, patterns, formats, chunks, layouts and sets
     # cards are not accessible at this point
@@ -22,13 +22,13 @@ module Cardio
 
         def reload_sets
           Card::Set::Pattern.reset
-          Card::Set.reset_modules
+          Card::Set.reset
           SetPatternLoader.new.load
           SetLoader.new(no_all: true).load
         end
 
         def load_initializers
-          Cardio.config.paths["mod/config/initializers"].existent.sort.each do |init|
+          Cardio.config.paths["late/initializers"].existent.sort.each do |init|
             load init
           end
         end

data/lib/cardio/mod/modfile_api.rb

@@ -0,0 +1,22 @@
+module Cardio
+  class Mod
+    # Methods used via "eval" in Modfiles
+    module ModfileApi
+      def mod mod_name, path=nil
+        @dirs.add_mod mod_name, path
+      end
+
+      def gem_mod name
+        deps = Mod.dependencies name
+        unknown_gem_mod!(name) if deps.blank?
+        deps.each { |spec| @dirs.add_gem_mod spec.name, spec.full_gem_path }
+      end
+
+      private
+
+      def unknown_gem_mod! name
+        raise Card::Error, %(Unknown gem "#{name}". Make sure it is in your Gemfile.)
+      end
+    end
+  end
+end

data/lib/cardio/mod/modfile_loader.rb

@@ -0,0 +1,18 @@
+require "cardio/mod/modfile_api"
+
+module Cardio
+  class Mod
+    # Loads the mod of a Modfile into a Mod::Dirs object
+    class ModfileLoader
+      include ModfileApi
+
+      def initialize dirs
+        @dirs = dirs
+      end
+
+      def load modfile_path
+        eval File.read(modfile_path), binding
+      end
+    end
+  end
+end

data/lib/cardio/mod/module_template.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     # ModuleTemplate is an abstract class to build ruby modules out of
     # deckos dsl for sets and set patterns.
     # {Loader::SetTemplate} and {Loader::SetPatternTemplate} inherit

data/lib/cardio/mod.rb

@@ -59,13 +59,62 @@ module Cardio
   #   - **set_pattern** for additional {Card::Set::Pattern set patterns},
   #     or types of sets.
   #   - **file** for fixed initial card content
-  module Mod
+  class Mod
+    attr_reader :name, :path, :index
+
+    def initialize name, path, index
+      @name = Mod.normalize_name name
+      @path = path
+      @index = index
+    end
+
+    def mod_card_name
+      "mod: #{name}"
+    end
+
+    def codename
+      "mod_#{name}"
+    end
+
+    def tmp_dir type
+      File.join Cardio.paths["tmp/#{type}"].first,
+                "mod#{'%03d' % (@index + 1)}-#{@name}"
+    end
+
+    def public_path
+      File.join @path, "public"
+    end
+
+    def assets_path
+      File.join @path, "assets"
+    end
+
+    def ensure_mod_installed
+      Card::Auth.as_bot do
+        card = ensure_mod_card
+        card.ensure_mod_script_card
+        card.ensure_mod_style_card
+      end
+    end
+
+    private
+
+    def ensure_mod_card
+      if Card::Codename.exists? codename
+        card = Card.fetch codename.to_sym
+        card.update type: :mod unless card.type_code == :mod
+        card
+      else
+        Card.create name: mod_card_name, type: :mod, codename: codename
+      end
+    end
+
     class << self
       def load
         return if ENV["CARD_MODS"] == "none"
 
         if Card.take
-          Cardio::Mod::Loader.load_mods
+          Loader.load_mods
         else
           Rails.logger.warn "empty database"
         end
@@ -96,6 +145,10 @@ module Cardio
         end
       end
 
+      def normalize_name name
+        name.to_s.sub(/^card-mod-/, "")
+      end
+
       private
 
       def gem_spec name, nickname=true

data/lib/cardio/railtie.rb

@@ -0,0 +1,138 @@
+module Cardio
+  # primary railtie for cards
+  class Railtie < Rails::Railtie
+    # if you disable inline styles tinymce's formatting options stop working
+    config.allow_inline_styles = true
+    config.delaying = nil
+    config.token_expiry = 2.days
+
+    config.recaptcha_public_key = nil  # deprecated; use recaptcha_site_key instead
+    config.recaptcha_private_key = nil # deprecated; use recaptcha_secret_key instead
+
+    config.recaptcha_proxy = nil
+    config.recaptcha_site_key = nil
+    config.recaptcha_secret_key = nil
+    config.recaptcha_minimum_score = 0.5
+
+    config.google_analytics_key = nil
+
+    config.override_host = nil
+    config.override_protocol = nil
+
+    config.no_authentication = false
+    config.files_web_path = "files"
+
+    config.max_char_count = 200
+    config.max_depth = 20
+    config.email_defaults = nil
+
+    config.acts_per_page = 10
+    config.space_last_in_multispace = true
+    config.closed_search_limit = 10
+    config.paging_limit = 20
+
+    config.non_createable_types = %w[
+      signup
+      setting
+      set
+      session
+      bootswatch_skin
+      customized_bootswatch_skin
+    ]
+
+    config.view_cache = false
+    config.rss_enabled = false
+    config.double_click = :signed_in
+
+    config.encoding = "utf-8"
+    config.request_logger = false
+    config.performance_logger = false
+    config.sql_comments = true
+
+    config.file_storage = :local
+    config.file_buckets = {}
+    config.file_default_bucket = nil
+    config.protocol_and_host = nil
+
+    config.rich_text_editor = :tinymce
+
+    config.persistent_cache = true
+    config.prepopulate_cache = false
+    config.machine_refresh = :cautious
+    config.compress_javascript = true
+
+    config.allow_irreversible_admin_tasks = false
+    config.raise_all_rendering_errors = false
+    config.rescue_all_in_controller = true
+    config.navbox_match_start_only = true
+
+    config.cache_set_module_list = false
+
+    config.i18n.enforce_available_locales = true
+    config.read_only = !ENV["DECKO_READ_ONLY"].nil?
+    config.load_strategy = (ENV["REPO_TMPSETS"] || ENV["TMPSETS"] ? :tmp_files : :eval)
+
+    # TODO: support mod-specific railties
+
+    config.before_configuration do |app|
+      card_root = Cardio.gem_root
+
+      app.config.tap do |c|
+        c.autoloader = :zeitwerk
+        c.autoload_paths += Dir["#{card_root}/lib"]
+
+        c.paths.tap do |p|
+          p["config/environments"].unshift "#{card_root}/config/environments"
+          p["config/initializers"] << "#{card_root}/config/initializers"
+          p.add "late/initializers", glob: "**/*.rb"
+
+          p["lib/tasks"] << "#{card_root}/lib/tasks"
+
+          p.add "mod", with: "#{card_root}/mod"
+          p["mod"] << "mod"
+          p.add "files"
+
+          p.add "lib/graph_q_l/types/query.rb"
+
+          p.add "db", with: "#{card_root}/db"
+          p.add "db/seeds.rb", with: "#{card_root}/db/seeds.rb"
+          p.add "db/migrate", with: "#{card_root}/db/migrate"
+          p.add "db/migrate_core_cards", with: "#{card_root}/db/migrate_core_cards"
+
+          p.add "db/migrate_deck", with: "db/migrate"
+          p.add "db/migrate_deck_cards", with: "db/migrate_cards"
+
+          Cardio::Mod.each_path do |mod_path|
+            c.autoload_paths += Dir["#{mod_path}/lib"]
+            c.watchable_dirs["#{mod_path}/set"] = %i[rb haml]
+
+            p["lib/graph_q_l/types/query.rb"] <<
+              "#{mod_path}/lib/graph_q_l/types/query.rb"
+            p["config/initializers"] << "#{mod_path}/init/early"
+            p["late/initializers"] << "#{mod_path}/init/late"
+            p["config/locales"] << "#{mod_path}/locales"
+            p["lib/tasks"] << "#{mod_path}/lib/tasks"
+          end
+
+          p["app/models"] = []
+          p["app/mailers"] = []
+          p["app/controllers"] = []
+        end
+      end
+    end
+
+    config.before_initialize do |app|
+      app.config.tap do |c|
+        if c.load_strategy == :tmp_files
+          %w[set set_pattern].each do |dir|
+            if ENV["REPO_TMPSETS"]
+              c.paths.add "tmp/#{dir}", with: "#{Cardio.gem_root}/tmpsets/#{dir}"
+            else
+              c.paths.add "tmp/#{dir}"
+            end
+          end
+        end
+      end
+    end
+  end
+end