card 1.103.4 → 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/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/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

data/lib/cardio/mod.rb

@@ -1,3 +1,5 @@
+require "cardio/mod/class_methods"
+
 module Cardio
   # A Card Mod (short for "module" or "modification") is a discrete piece of Decko
   # functionality. Mods are how the Decko community develops and shares code.
@@ -60,11 +62,13 @@ module Cardio
   #     or types of sets.
   #   - **file** for fixed initial card content
   class Mod
+    extend ClassMethods
+
     attr_reader :name, :path, :index
 
     def initialize name, path, index
       @name = Mod.normalize_name name
-      @path = path
+      @path = required_path path
       @index = index
     end
 
@@ -76,30 +80,34 @@ module Cardio
       "mod_#{name}"
     end
 
+    def subpath *parts
+      path = File.join [@path] + parts
+      path if File.exist? path
+    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
+    def ensure
       Card::Auth.as_bot do
-        card = ensure_mod_card
+        card = ensure_card
         card.ensure_mod_script_card
         card.ensure_mod_style_card
+        Card::Cache.reset_all
       end
     end
 
     private
 
-    def ensure_mod_card
+    def required_path path
+      return path if File.exist? path
+
+      raise Card::Error::NotFound, "mod not found: #{@name}"
+    end
+
+    def ensure_card
       if Card::Codename.exists? codename
         card = Card.fetch codename.to_sym
         card.update type: :mod unless card.type_code == :mod
@@ -108,73 +116,5 @@ module Cardio
         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
-          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 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
-
-      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
-        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/railtie.rb

@@ -15,6 +15,8 @@ module Cardio
     config.recaptcha_minimum_score = 0.5
 
     config.google_analytics_key = nil
+    config.google_analytics_tracker_key = nil
+    config.google_analytics_four_key = nil
 
     config.override_host = nil
     config.override_protocol = nil
@@ -38,6 +40,14 @@ module Cardio
       session
       bootswatch_skin
       customized_bootswatch_skin
+      local_folder_group
+      local_manifest_group
+      local_script_folder_group
+      local_script_manifest_group
+      local_style_folder_group
+      local_style_manifest_group
+      remote_manifest_group
+      mod
     ]
 
     config.view_cache = false
@@ -47,7 +57,7 @@ module Cardio
     config.encoding = "utf-8"
     config.request_logger = false
     config.performance_logger = false
-    config.sql_comments = true
+    config.sql_comments = false
 
     config.file_storage = :local
     config.file_buckets = {}
@@ -58,8 +68,8 @@ module Cardio
 
     config.persistent_cache = true
     config.prepopulate_cache = false
-    config.machine_refresh = :cautious
-    config.compress_javascript = true
+    config.asset_refresh = :cautious
+    config.compress_assets = true
 
     config.allow_irreversible_admin_tasks = false
     config.raise_all_rendering_errors = false
@@ -93,6 +103,7 @@ module Cardio
           p.add "files"
 
           p.add "lib/graph_q_l/types/query.rb"
+          p.add "mod-data"
 
           p.add "db", with: "#{card_root}/db"
           p.add "db/seeds.rb", with: "#{card_root}/db/seeds.rb"
@@ -112,6 +123,7 @@ module Cardio
             p["late/initializers"] << "#{mod_path}/init/late"
             p["config/locales"] << "#{mod_path}/locales"
             p["lib/tasks"] << "#{mod_path}/lib/tasks"
+            p["mod-data"] << "#{mod_path}/data"
           end
 
           p["app/models"] = []