card 1.101.6 → 1.103.1

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

@@ -1,56 +1,59 @@
 module Cardio
-  module Mod
+  class Mod
     class Loader
       class SetPatternLoader < Loader
-        @module_type = :set_pattern
-
-        def load_strategy_class load_strategy
-          case load_strategy
-          when :tmp_files
-            LoadStrategy::PatternTmpFiles
-          else # :eval
-            LoadStrategy::Eval
-          end
+        def template_class
+          SetPatternTemplate
         end
 
-        class Template < ModuleTemplate
-          def to_const
-            return Object if simple_load?
+        def load_strategy_class strategy
+          LoadStrategy.class_for_set_pattern strategy
+        end
 
-            Card::Set.const_get_or_set(@pattern.camelize) do
-              Class.new(Card::Set::Pattern::Base)
-            end
+        def each_file &block
+          each_mod_dir :set_pattern do |base_dir|
+            each_file_in_dir base_dir, &block
           end
+        end
+      end
+
+      class SetPatternTemplate < ModuleTemplate
+        def to_const
+          return Object if simple_load?
 
-          # correct line number for error messages
-          def offset
-            -5
+          Card::Set.const_get_or_set(@pattern.camelize) do
+            Class.new(Card::Set::Pattern::Base)
           end
+        end
 
-          private
+        # correct line number for error messages
+        def offset
+          -5
+        end
 
-          def auto_comment
-            %(# Set Pattern: #{@pattern.camelize}\n#)
-          end
+        private
 
-          def module_chain
-            "class Card::Set::#{@pattern.camelize} < Card::Set::Pattern::Base"
-          end
+        def auto_comment
+          %(# Set Pattern: #{@pattern.camelize}\n#)
+        end
 
-          def preamble_bits
-            [module_comment,
-             module_chain,
-             "cattr_accessor :options",
-             "class << self"]
-          end
+        def module_chain
+          "class Card::Set::#{@pattern.camelize} < Card::Set::Pattern::Base"
+        end
+
+        def preamble_bits
+          [module_comment,
+           module_chain,
+           "cattr_accessor :options",
+           "class << self"]
+        end
 
-          def postamble
-            <<-RUBY
-              end
-              register "#{@pattern}".underscore.to_sym, (options || {})
+        def postamble
+          <<-RUBY
             end
-            RUBY
+            register "#{@pattern}".underscore.to_sym, (options || {})
           end
+          RUBY
         end
       end
     end

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

@@ -0,0 +1,131 @@
+module Cardio
+  class Mod
+    class Loader
+      # Template for set modules
+      class SetTemplate < ModuleTemplate
+        def initialize modules, content_path, strategy
+          super
+          @modules.pop if helper_module?
+        end
+
+        def to_const
+          return Object if simple_load?
+
+          @modules.inject(pattern_class) do |const, name_part|
+            const.const_get_or_set name_part do
+              Module.new
+            end
+          end
+        end
+
+        def processed_content
+          add_explicit_format_modules if @strategy.clean_comments?
+          super
+        end
+
+        def add_explicit_format_modules
+          @content.gsub!(/^ *format +:?(\w+)? *do *$/) do
+            format_name = Regexp.last_match(1)
+            format_name = format_name.blank? ? nil : format_name.to_sym
+            "module #{module_name format_name}; " \
+            "module_parent.send :register_set_format, "\
+            "#{format_class format_name}, self; "\
+            "extend Card::Set::AbstractFormat"
+          end
+        end
+
+        def module_name format_name
+          Card::Format.format_class_name format_name
+        end
+
+        def format_class format_name
+          klass = ["Card::Format"]
+          klass << module_name(format_name) if format_name
+          klass.join "::"
+        end
+
+        def helper_module?
+          if @is_helper_module.nil?
+            @is_helper_module = @content =~ /\A#!\s?not? set module/
+          else
+            @is_helper_module
+          end
+        end
+
+        # correct line number for error messages
+        def offset
+          -5
+        end
+
+        private
+
+        def submodule_chain
+          @modules.map { |m| "module #{m};" }
+        end
+
+        def module_chain
+          @module_chain ||=
+            ["class Card", "module Set", "class #{@pattern.camelize}"] + submodule_chain
+        end
+
+        def preamble_bits
+          capture_last_module
+          [module_chain.join("; "),
+           module_comment,
+           @last_module,
+           set_extension,
+           location_method].compact
+        end
+
+        def auto_comment
+          "# Set: #{label_body(*@modules)}\n#"
+        end
+
+        def label_body *anchors
+          if @pattern == "Abstract"
+            "Abstract (#{@modules.join ', '})"
+          else
+            pattern_label(*anchors)
+          end
+        end
+
+        def pattern_label *anchors
+          anchor_count = pattern_class.anchor_parts_count
+          label = pattern_class.label(pattern_anchor(*anchors, anchor_count))
+          remainder = anchors[anchor_count..-1]
+          label += " (#{remainder.join ', '})" if remainder.any?
+          label
+        end
+
+        def pattern_anchor *anchors, anchor_count
+          if anchor_count.zero?
+            ""
+          else
+            anchors[0..anchor_count].join(Card::Name.joint)
+          end
+        end
+
+        def pattern_class
+          @pattern_class ||= Card::Set.const_get_or_set(@pattern.camelize) { Class.new }
+        end
+
+        def capture_last_module
+          module_chain
+          @last_module = @module_chain.pop
+        end
+
+        def set_extension
+          "extend Card::Set" unless helper_module?
+        end
+
+        def location_method
+          %(def self.source_location; "#{@content_path}"; end)
+        end
+
+        def postamble
+          "end;" * (@modules.size + 3)
+        end
+      end
+    end
+  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,8 +1,8 @@
 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::SetLoader::Template} and {Loader::SetPatternLoader::Template} inherit
+    # {Loader::SetTemplate} and {Loader::SetPatternTemplate} inherit
     # from it and adapt the template to their needs.
     class ModuleTemplate
       def initialize modules, content_path, strategy

data/lib/cardio/railtie.rb

@@ -0,0 +1,134 @@
+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/card/tasks"
+
+          p.add "mod", with: "#{card_root}/mod"
+          p["mod"] << "mod"
+          p.add "files"
+
+          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["config/initializers"] << "#{mod_path}/init/early"
+            p["late/initializers"] << "#{mod_path}/init/late"
+            p["config/locales"] << "#{mod_path}/locales"
+          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

data/lib/cardio/record.rb

@@ -0,0 +1,5 @@
+module Cardio
+  class Record < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/lib/cardio/schema.rb

@@ -1,87 +1,94 @@
 module Cardio
   module Schema
-    def assume_migrated_upto_version type
-      Cardio.schema_mode(type) do
-        ActiveRecord::Schema.assume_migrated_upto_version(Cardio.schema(type),
-                                                          Cardio.migration_paths(type))
+    class << self
+      def assume_migrated_upto_version type
+        mode type do |paths|
+          ActiveRecord::Schema.assume_migrated_upto_version version(type), paths
+        end
       end
-    end
 
-    def migrate type, version=nil, verbose=true
-      migration_context type do |mc|
-        ActiveRecord::Migration.verbose = verbose
-        mc.migrate version
+      def migrate type, version=nil, verbose=true
+        migration_context type do |mc|
+          ActiveRecord::Migration.verbose = verbose
+          mc.migrate version
+        end
       end
-    end
 
-    def schema_suffix type
-      case type
-      when :core_cards then "_core_cards"
-      when :deck_cards then "_deck_cards"
-      when :deck then "_deck"
-      else ""
+      def suffix type
+        case type
+        when :core_cards then "_core_cards"
+        when :deck_cards then "_deck_cards"
+        when :deck then "_deck"
+        else ""
+        end
       end
-    end
 
-    def schema_mode type
-      with_suffix type do
-        paths = Cardio.migration_paths(type)
-        yield(paths)
+      def mode type
+        with_suffix type do
+          yield migration_paths(type)
+        end
       end
-    end
 
-    def migration_context type
-      with_suffix type do
-        yield ActiveRecord::MigrationContext.new(Cardio.migration_paths(type),
-                                                 ActiveRecord::SchemaMigration)
+      def version type=nil
+        File.read(stamp_path(type)).strip
       end
-    end
 
-    def with_suffix type, &block
-      return yield unless (new_suffix = Cardio.schema_suffix type) &&
-                          new_suffix.present?
+      def stamp_path type
+        root_dir = deck_migration?(type) ? Cardio.root : Cardio.gem_root
+        stamp_dir = ENV["SCHEMA_STAMP_PATH"] || File.join(root_dir, "db")
 
-      original_name = ActiveRecord::Base.schema_migrations_table_name
-      with_migration_table "#{original_name}#{new_suffix}", original_name, &block
-    end
+        File.join stamp_dir, "version#{suffix type}.txt"
+      end
 
-    def with_migration_table new_table_name, old_table_name
-      ActiveRecord::Base.schema_migrations_table_name = new_table_name
-      ActiveRecord::SchemaMigration.table_name = new_table_name
-      ActiveRecord::SchemaMigration.reset_column_information
-      yield
-    ensure
-      ActiveRecord::Base.schema_migrations_table_name = old_table_name
-      ActiveRecord::SchemaMigration.table_name = old_table_name
-      ActiveRecord::SchemaMigration.reset_column_information
-    end
+      def migration_paths type
+        list = Cardio.paths["db/migrate#{suffix type}"].to_a
+        case type
+        when :core_cards
+          list += mod_migration_paths "migrate_core_cards"
+        when :deck_cards
+          list += mod_migration_paths "migrate_cards"
+        when :deck
+          list += mod_migration_paths "migrate"
+        end
+        list.flatten
+      end
 
-    def schema type=nil
-      File.read(schema_stamp_path(type)).strip
-    end
+      private
 
-    def schema_stamp_path type
-      root_dir = deck_migration?(type) ? root : gem_root
-      stamp_dir = ENV["SCHEMA_STAMP_PATH"] || File.join(root_dir, "db")
+      def deck_migration? type
+        type.in? %i[deck_cards deck]
+      end
 
-      File.join stamp_dir, "version#{schema_suffix type}.txt"
-    end
+      def mod_migration_paths dir
+        [].tap do |list|
+          Mod.dirs.each("db/#{dir}") { |path| list.concat Dir.glob path }
+        end
+      end
 
-    def deck_migration? type
-      type.in? %i[deck_cards deck]
-    end
+      def with_suffix type, &block
+        return yield unless (new_suffix = suffix type).present?
+
+        original_name = ActiveRecord::Base.schema_migrations_table_name
+        with_migration_table "#{original_name}#{new_suffix}", original_name, &block
+      end
+
+      def with_migration_table new_table_name, old_table_name
+        ActiveRecord::Base.schema_migrations_table_name = new_table_name
+        ActiveRecord::SchemaMigration.table_name = new_table_name
+        ActiveRecord::SchemaMigration.reset_column_information
+        yield
+      ensure
+        ActiveRecord::Base.schema_migrations_table_name = old_table_name
+        ActiveRecord::SchemaMigration.table_name = old_table_name
+        ActiveRecord::SchemaMigration.reset_column_information
+      end
 
-    def migration_paths type
-      list = paths["db/migrate#{schema_suffix type}"].to_a
-      case type
-      when :core_cards
-        list += mod_migration_paths "migrate_core_cards"
-      when :deck_cards
-        list += mod_migration_paths "migrate_cards"
-      when :deck
-        list += mod_migration_paths "migrate"
+      def migration_context type
+        with_suffix type do
+          yield ActiveRecord::MigrationContext.new(migration_paths(type),
+                                                   ActiveRecord::SchemaMigration)
+        end
       end
-      list.flatten
     end
   end
 end