card 1.103.1 → 1.104.0

data/lib/cardio/mod/class_methods.rb

@@ -0,0 +1,112 @@
+module Cardio
+  class Mod
+    # class methods for Cardio::Mod
+    module ClassMethods
+      def load
+        return if ENV["CARD_MODS"] == "none"
+
+        if Card.take
+          Loader.load_mods
+        else
+          Rails.logger.warn "empty database"
+        end
+      end
+
+      # @return an array of Rails::Path objects
+      def dirs
+        @dirs ||= Mod::Dirs.new Cardio.paths["mod"].existent
+      end
+
+      def fetch mod_name
+        dirs.fetch_mod mod_name
+      end
+
+      def normalize_name name
+        name.to_s.sub(/^card-mod-/, "")
+      end
+
+      def missing
+        Card.search(type: :mod).reject { |mod_card| fetch mod_card.modname }
+      end
+
+      def ensure_uninstalled
+        missing.each do |mod_card|
+          Card::Auth.as_bot do
+            Card[:all, :style].drop_item mod_card
+            delete_auto_installed_cards mod_card
+          end
+        end
+      end
+
+      def ensure_installed
+        Card::Cache.reset_all
+        puts "installing card mods".green
+        Cardio.mods.each(&:ensure)
+        Card::Assets.refresh_assets force: true
+      end
+
+      def dependencies name, nickname=true
+        return unless (spec = gem_spec name, nickname)
+
+        deps = spec&.dependencies || []
+        dep_names = deps.map { |dep| dependencies dep.name, false }
+        (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
+
+      private
+
+      # it would be nice if this were easier...
+      def delete_auto_installed_cards mod_card
+        auto_installed_cards(mod_card).each do |card|
+          card.codename = nil
+          card.delete!
+        end
+      end
+
+      def auto_installed_cards mod_card
+        [mod_card].tap do |cards|
+          mod_card.each_descendant do |card|
+            cards.unshift card
+          end
+        end
+      end
+
+      def gem_spec name, nickname=true
+        name = "card-mod-#{name}" if nickname && !name.match?(/^card-mod/)
+        spec = Gem::Specification.stubs_for(name)&.first
+        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
+end

data/lib/cardio/mod/dirs.rb

@@ -97,6 +97,13 @@ module Cardio
         fetch_mod(mod_name)&.path
       end
 
+      def subpaths *subdirs
+        @mods.each_with_object({}) do |mod, hash|
+          path = mod.subpath(*subdirs)
+          hash[mod.name] = path if path
+        end
+      end
+
       def fetch_mod mod_name
         @mods_by_name[Mod.normalize_name(mod_name)]
       end
@@ -129,12 +136,15 @@ module Cardio
         end
       end
 
-      def each_public_path
-        @mods.each do |mod|
-          path = mod.public_path
-          next unless Dir.exist? path
+      def each_subpath *subdirs
+        subpaths(*subdirs).each do |mod_name, subpath|
+          yield mod_name, subpath
+        end
+      end
 
-          yield mod.name, path
+      def load_from_gemfile
+        Cardio::Mod.gem_specs.each do |mod_name, mod_spec|
+          add_gem_mod mod_name, mod_spec.full_gem_path
         end
       end
 
@@ -154,12 +164,6 @@ module Cardio
           add_mod filename unless filename.match?(/^\./)
         end
       end
-
-      def load_from_gemfile
-        Cardio::Mod.gem_specs.each do |mod_name, mod_spec|
-          add_gem_mod mod_name, mod_spec.full_gem_path
-        end
-      end
     end
   end
 end

data/lib/cardio/mod/eat/edibles.rb

@@ -0,0 +1,92 @@
+module Cardio
+  class Mod
+    class Eat
+      # item handling for Mod::Eat (importables)
+      module Edibles
+        # list of card attribute hashes
+        # @return [Array <Hash>]
+        def edibles
+          mods_with_data.map { |mod| mod_edibles mod }.flatten
+        end
+
+        private
+
+        # if mod is specified, consider only that mod
+        # @return [Array <Cardio::Mod>]
+        def mods_with_data
+          paths = Mod.dirs.subpaths "data"
+          mod_names = @mod ? ensure_mod_data_path(paths) : paths.keys
+          mod_names.map { |mod_name| Mod.fetch mod_name }
+        end
+
+        def ensure_mod_data_path paths
+          return [@mod] if paths[@mod]
+
+          raise "no data directory found for mod #{@mod}".red
+        end
+
+        # @return [Array <Hash>]
+        def mod_edibles mod
+          environments.map { |env| items_for_environment mod, env }.compact
+        end
+
+        def items_for_environment mod, env
+          return unless (items = items_from_yaml mod, env)
+
+          items = items.map do |item|
+            item.is_a?(String) ? items_from_yaml(mod, env, item) : item
+          end.flatten.compact
+          interpret_items mod, items
+        end
+
+        def interpret_items mod, items
+          each_card_hash(items) { |hash| handle_attachments mod, hash }
+        end
+
+        def items_from_yaml mod, env, filename=nil
+          source = "#{env}#{'/' if filename.present?}#{filename}.yml"
+          return unless (path = mod.subpath "data", source)
+
+          YAML.load_file path
+        end
+
+        # for processing that needs to happen on all cards, including fields
+        def each_card_hash items
+          items.each do |item|
+            yield item
+            item[:subfields]&.values&.each { |val| yield val if val.is_a? Hash }
+          end
+          items
+        end
+
+        def handle_attachments mod, hash
+          each_attachment hash do |key, filename|
+            hash[key] = mod_file mod, filename
+            hash[:mod] = mod.name if hash[:storage_type] == :coded
+          end
+        end
+
+        def each_attachment hash
+          attachment_keys.each { |key| yield key, hash[key] if hash.key? key }
+        end
+
+        def mod_file mod, filename
+          File.open mod.subpath("data/files", filename)
+        end
+
+        def attachment_keys
+          @attachment_keys ||= Card.uploaders.keys
+        end
+
+        # @return [Array <Symbol>]
+        # holarchical. each includes the previous
+        # production = [:production],
+        # development = [:production, :development], etc.
+        def environments
+          index = DATA_ENVIRONMENTS.index(@env&.to_sym || Rails.env.to_sym) || -1
+          DATA_ENVIRONMENTS[0..index]
+        end
+      end
+    end
+  end
+end

data/lib/cardio/mod/eat.rb

@@ -0,0 +1,81 @@
+require "timecop"
+
+require "pry"
+
+DATA_ENVIRONMENTS = %i[production development test].freeze
+ENV["STORE_CODED_FILES"] = "true"
+
+module Cardio
+  class Mod
+    # import data from data directory of mods
+    # (list of card attributes)
+    # https://docs.google.com/document/d/13K_ynFwfpHwc3t5gnLeAkZJZHco1wK063nJNYwU8qfc/edit#
+    class Eat
+      include Card::Model::SaveHelper
+      include Edibles
+
+      def initialize mod: nil, env: nil, user: nil, verbose: nil
+        @mod = mod
+        @env = env
+        @user_id = user&.card_id
+        @verbose = !verbose.nil?
+      end
+
+      def up
+        Card::Cache.reset_all
+        Card::Mailer.perform_deliveries = false
+        Card::Auth.as_bot do
+          edibles.each do |edible|
+            track edible do
+              current_user edible.delete(:user)
+              time_machine edible.delete(:time) do
+                ensure_card edible
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def track edible
+        rescuing edible do
+          # puts "eat: #{edible}" if @verbose
+          card = yield
+          puts "eaten: #{card.name}".green # if @verbose
+        end
+      end
+
+      def rescuing edible
+        yield
+      rescue StandardError => e
+        # binding.pry
+        puts edible
+        puts e.message.red
+        puts e.backtrace.join("\n") if @verbose
+      end
+
+      def current_user item_user
+        Card::Auth.current_id = item_user&.card_id || @user_id || Card::WagnBotID
+      end
+
+      def time_machine value, &block
+        return yield unless value.present?
+
+        Timecop.freeze Time.at(time_integer(value)), &block
+      end
+
+      def time_integer value
+        case value
+        when /^[+-]\d+$/
+          # plus or minus an integer (safe to eval)
+          eval "#{Time.now.to_i} #{value}", binding, __FILE__, __LINE__
+        when Integer
+          value
+        else
+          raise TypeError, "invalid time value: #{value}. accepts int, +int, and -int"
+        end
+      end
+    end
+  end
+end

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

@@ -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

@@ -20,7 +20,7 @@ module Cardio
 
           p = Card.paths[path]
           FileUtils.rm_rf p.first, secure: true if p.existent.first
-          Dir.mkdir p.first
+          FileUtils.mkdir_p p.first
         end
 
         def rewrite_tmp_files?

data/lib/cardio/mod/load_strategy.rb

@@ -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

@@ -5,10 +5,6 @@ module Cardio
       # 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.rb

@@ -22,7 +22,7 @@ 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

data/lib/cardio/mod/modfile_api.rb

@@ -12,6 +12,11 @@ module Cardio
         deps.each { |spec| @dirs.add_gem_mod spec.name, spec.full_gem_path }
       end
 
+      # load all gem mods
+      def gem_mods
+        @dirs.load_from_gemfile
+      end
+
       private
 
       def unknown_gem_mod! name

data/lib/cardio/mod/poop.rb

@@ -0,0 +1,135 @@
+module Cardio
+  class Mod
+    # POOP (or Plain Old OutPut) is our nickname for our standard card YAML,
+    # used to define cards associated with mods.
+    #
+    # Monkeys throw it around, and Sharks can eat it (if you believe this guy:
+    # https://www.youtube.com/watch?v=VvEa4NSqw7I).
+    #
+    # https://docs.google.com/document/d/13K_ynFwfpHwc3t5gnLeAkZJZHco1wK063nJNYwU8qfc/edit#
+    class Poop
+      def initialize **args
+        @mod = args[:mod]
+        @name = args[:name]
+        @cql = args[:cql]
+        @env = args[:env] || Rails.env
+        @items = args[:items]
+        @field_tags = args[:field_tags]
+      end
+
+      # @return [Array <Hash>]
+      def new_data
+        @new_data ||= cards.map { |c| c.export_hash field_tags: field_tag_marks }
+      end
+
+      def field_tag_marks
+        @field_tag_marks ||= @field_tags.to_s.split(",").map do |mark|
+          mark.strip.cardname.codename_or_string
+        end
+      end
+
+      # @return [String] -- MOD_DIR/data/ENVIRONMENT.yml
+      def filename
+        @filename ||= File.join mod_path, "#{@env}.yml"
+      end
+
+      # if output mod given,
+      def out
+        Card::Cache.reset_all
+        @mod ? dump : puts(new_data.to_yaml.yellow)
+        :success
+      rescue Card::Error::NotFound => e
+        e.message
+      rescue JSON::ParserError => e
+        e.message
+      end
+
+      # write yaml to file
+      def dump
+        hash = output_hash
+        File.write filename, hash.to_yaml
+        puts "#{filename} now contains #{hash.size} items".green
+      end
+
+      private
+
+      def cards
+        if @name
+          cards_from_name
+        elsif @cql
+          Card.search JSON.parse(@cql).reverse_merge(limit: 0)
+        else
+          raise Card::Error::NotFound, "must specify either name (-n) or CQL (-c)"
+        end
+      end
+
+      def cards_from_name
+        case @items
+        when :only
+          item_cards
+        when true
+          main_cards + item_cards
+        else
+          main_cards
+        end
+      end
+
+      def item_cards
+        main_cards.map { |mc| mc.item_cards }.flatten
+      end
+
+      def main_cards
+        @main_cards ||= @name.split(",").map { |n| require_card n }
+      end
+
+      def require_card name
+        Card.fetch(name) || raise(Card::Error::NotFound, "card not found: #{name}")
+      end
+
+      def output_hash
+        if target.present?
+          merge_data
+          target
+        else
+          new_data
+        end
+      end
+
+      def merge_data
+        new_data.each do |item|
+          if (index = target_index item)
+            target[index] = item
+          else
+            target << item
+          end
+        end
+      end
+
+      def target_index new_item
+        new_code = new_item[:codename]
+        new_name = new_item[:name].to_name
+        target.find_index do |t|
+          t.is_a?(Hash) &&
+            ((new_code.present? && (new_code == t[:codename])) ||
+              (t[:name].to_name == new_name))
+        end
+      end
+
+      def target
+        @target ||= old_data
+      end
+
+      def old_data
+        return nil unless File.exist? filename
+
+        YAML.safe_load File.read(filename), [Symbol]
+      end
+
+      # @return Path
+      def mod_path
+        Mod.dirs.subpaths("data")[@mod] ||
+          raise(Card::Error::NotFound, "no data directory found for mod: #{@mod}")
+      end
+    end
+  end
+end