card 1.101.7 → 1.103.2

data/lib/cardio/generators/mod_base.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+
+module Cardio
+  module Generators
+    # base class for mod-related generators
+    class ModBase < ::Rails::Generators::NamedBase
+      extend ClassMethods
+
+      class_option "mod-path", aliases: "-m", group: :runtime, desc: "full path for mod"
+
+      def mod_path
+        @mod_path = if (path = options["mod-path"])
+                      File.expand_path path
+                    else
+                      File.join "mod", file_name
+                    end
+      end
+    end
+  end
+end

data/lib/cardio/generators/rails_overrides.rb

@@ -0,0 +1,50 @@
+module Cardio
+  module Generators
+    ### the following is straight from rails and is focused on checking
+    # the validity of the app name.needs decko-specific tuning
+    module RailsOverrides
+      protected
+
+      def app_name
+        @app_name ||=
+          defined_app_const_base? ? defined_app_name : File.basename(destination_root)
+      end
+
+      def defined_app_name
+        defined_app_const_base.underscore
+      end
+
+      def defined_app_const_base
+        Rails.respond_to?(:application) && defined?(Rails::Application) &&
+          Cardio.application.is_a?(Rails::Application) &&
+          Cardio.application.class.name.sub(/::Application$/, "")
+      end
+
+      alias_method :defined_app_const_base?, :defined_app_const_base
+
+      def app_const_base
+        @app_const_base ||= defined_app_const_base ||
+                            app_name.gsub(/\W/, "_").squeeze("_").camelize
+      end
+
+      alias_method :camelized, :app_const_base
+
+      def app_const
+        @app_const ||= "#{app_const_base}::Application"
+      end
+
+      def valid_const?
+        if app_const.match?(/^\d/)
+          invalid_app_name "Please give a name which does not start with numbers."
+        elsif Object.const_defined?(app_const_base)
+          invalid_app_name "constant #{app_const_base} is already in use. " \
+                           "Please choose another application name."
+        end
+      end
+
+      def invalid_app_name message
+        raise Thor::Error, "Invalid application name #{app_name}, #{message}"
+      end
+    end
+  end
+end

data/lib/cardio/job.rb

@@ -0,0 +1,5 @@
+module Cardio
+  class Job < ActiveJob::Base
+
+  end
+end

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/migration/deck_structure.rb

@@ -10,7 +10,7 @@ module Cardio
       @type = :deck
 
       def contentedly &block
-        Cardio.schema_mode :deck, &block
+        Schema.mode :deck, &block
       end
     end
   end

data/lib/cardio/migration/import/merger.rb

@@ -12,16 +12,26 @@ module Cardio
         def merge
           puts("nothing to merge") && return if @data.empty?
 
-          Card::Mailer.perform_deliveries = false
-          Card::Auth.as_bot do
-            Card.merge_list @data, output_file: @output_path
-          end
+          without_mail_deliveries do
+            Card::Auth.as_bot do
+              Card.merge_list @data, output_file: @output_path
+            end
 
-          update_import_data
+            update_import_data
+          end
         end
 
         private
 
+        def without_mail_deliveries
+          m = Card::Mailer
+          prior = m.perform_deliveries
+          m.perform_deliveries = false
+          yield
+        ensure
+          m.perform_deliveries = prior
+        end
+
         def update_import_data
           update_time = Time.zone.now.to_s
           ImportData.update(@data_path) do |import_data|

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
@@ -84,10 +133,47 @@ module Cardio
         (dep_names << spec).flatten.compact.uniq
       end
 
+      def each_path &block
+        each_simple_path(&block)
+        each_gem_path(&block)
+      end
+
+      # @return [Hash] in the form{ modname(String) => Gem::Specification }
+      def gem_specs
+        Bundler.definition.specs.each_with_object({}) do |gem_spec, h|
+          h[gem_spec.name] = gem_spec if gem_spec? gem_spec
+        end
+      end
+
+      def normalize_name name
+        name.to_s.sub(/^card-mod-/, "")
+      end
+
+      private
+
       def gem_spec name, nickname=true
         name = "card-mod-#{name}" if nickname && !name.match?(/^card-mod/)
         spec = Gem::Specification.stubs_for(name)&.first
-        Cardio.gem_mod_spec?(spec) ? spec : nil
+        gem_spec?(spec) ? spec : nil
+      end
+
+      def each_simple_path &block
+        Cardio.paths["mod"].each do |mods_path|
+          Dir.glob("#{mods_path}/*").each(&block)
+        end
+      end
+
+      def each_gem_path
+        gem_specs.each_value do |spec|
+          yield spec.full_gem_path
+        end
+      end
+
+      # @return [True/False]
+      def gem_spec? spec
+        return unless spec
+
+        spec.name.match?(/^card-mod-/) || spec.metadata["card-mod"].present?
       end
     end
   end

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,27 +144,22 @@ 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
 
       def load_from_gemfile
-        Cardio.gem_mod_specs.each do |mod_name, mod_spec|
+        Cardio::Mod.gem_specs.each do |mod_name, mod_spec|
           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