card 1.105.6 → 1.106.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19bf849da74214f9ae14d6bc7310c0015209de781b3b9fa89c509a0665167971
-  data.tar.gz: 83e55e8f3b6b6791f861938f594dd897fb0ac817fd0be4b922dbe71b707fa435
+  metadata.gz: 5a8e1bc39a0131940fbec71fd5a92601c334c895d67d4781e8b03c109d7e0f59
+  data.tar.gz: 14bbcc9ac8d90d9a4f3a361710510d43f516ebe7a147f028c31b6cf903b3fd67
 SHA512:
-  metadata.gz: ed6f5f0ecd5bfcbf75efeb9f3d9c152e33433e0b6581a3b81971932ef819099cd3157fedb2ad752e3509fe5a4298cec4d9bbfed823fbd5a57d29e71ea0252b90
-  data.tar.gz: b661938ed367e6f58818107288baf4e248c2ce0725a2c777da2ee30b02b33902a441844aeb1ba81cd677c0774473010b2a241d6e320a2b094b50eb48dc147ba3
+  metadata.gz: d215a5fa5a0557d60a9a17ee7a6a4ee134206281ea96c7d3c3665be0f81756fc251055ea27a52c7f0ec2652cc2b91b559006f17816d43594c0fbebcee1c7baf9
+  data.tar.gz: e2af61cd07919b7759d9af5f66507f06d5320d8b430974ffa296512466e7d61fd4b5bb56fe2af3120ac0928c19420daa53156cce7fee2b1b3244bfcd434da582

data/VERSION

@@ -1 +1 @@
-0.15.6
+0.16.0

data/config/initializers/02_patches/active_record.rb

@@ -121,8 +121,8 @@ module Patches
     module Migration
       module ClassMethods
         def check_pending! connection=::ActiveRecord::Base.connection
-          %i[structure core_cards deck deck_cards].each do |migration_type|
-            Cardio::Schema.mode(migration_type) do |paths|
+          %i[schema transform].each do |migration_type|
+            Cardio::Migration.new_for(migration_type).mode do |paths|
               ::ActiveRecord::Migrator.migrations_paths = paths
               super
             end

data/db/schema.rb

@@ -114,19 +114,6 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
     t.index ["priority", "run_at"], name: "delayed_jobs_priority"
   end
 
-  create_table "schema_migrations_core_cards", id: false, charset: "utf8mb3", force: :cascade do |t|
-    t.string "version", null: false
-    t.index ["version"], name: "unique_schema_migrations_cards", unique: true
-  end
-
-  create_table "schema_migrations_deck", primary_key: "version", id: :string, charset: "utf8mb3", force: :cascade do |t|
-  end
-
-  create_table "schema_migrations_deck_cards", id: false, charset: "utf8mb3", force: :cascade do |t|
-    t.string "version", null: false
-    t.index ["version"], name: "unique_schema_migrations_deck_cards", unique: true
-  end
-
   create_table "sessions", id: :integer, charset: "utf8mb3", force: :cascade do |t|
     t.string "session_id"
     t.text "data"
@@ -134,6 +121,11 @@ ActiveRecord::Schema.define(version: 2022_10_31_182227) do
     t.index ["session_id"], name: "sessions_session_id_index"
   end
 
+  create_table "transform_migrations", id: false, charset: "utf8mb3", force: :cascade do |t|
+    t.string "version", null: false
+    t.index ["version"], name: "unique_schema_migrations_cards", unique: true
+  end
+
   create_table "users", id: :integer, charset: "utf8mb3", force: :cascade do |t|
     t.string "login", limit: 40
     t.string "email", limit: 100

data/lib/card/codename.rb

@@ -95,6 +95,14 @@ class Card
         end
       end
 
+      def recode oldcode, newcode
+        return unless id(oldcode) && !id(newcode)
+
+        puts "recode #{oldcode}, #{newcode}"
+        Card.where(codename: oldcode).take.update_column :codename, newcode
+        reset_cache
+      end
+
       private
 
       # iterate through every card with a codename

data/lib/card/director/store.rb

@@ -7,7 +7,7 @@ class Card
         @after_store << block
       end
 
-      protected
+      # protected
 
       def after_store?
         @after_store.present?

data/lib/card/model/save_helper/save_helper_helper.rb

@@ -21,8 +21,12 @@ class Card
           method_name, cardtype_card = extract_cardtype_from_method_name method
           return super unless method_name
 
-          sargs = standardize_args(*args)
-          send "#{method_name}_card", sargs.merge(type_id: cardtype_card.id)
+          sargs = standardize_args(*args).merge(type_id: cardtype_card.id)
+          if method_name == "ensure"
+            Card.ensure sargs
+          else
+            send "#{method_name}_card", sargs
+          end
         end
 
         def respond_to_missing? method, _include_private=false

data/lib/card/query/abstract_query/tie.rb

@@ -97,6 +97,20 @@ class Card
           when String, Symbol  then val.card_id || -999
           end
         end
+
+        def op_and_id_or_ids_from_val val
+          if (single_id = id_from_val val)
+            "= #{single_id}"
+          elsif list_of_ids? val
+            "in (#{val.map { |v| id_from_val v }.join ', '})"
+          end
+        end
+
+        def list_of_ids? val
+          return unless val.is_a? Array
+
+          !val.find { |v| !id_from_val v }
+        end
       end
     end
   end

data/lib/card/query/card_query/interpretation.rb

@@ -80,6 +80,7 @@ class Card
         def relate key, val, opts={}
           multiple = opts[:multiple].nil? ? val.is_a?(Array) : opts[:multiple]
           method = opts[:method] || :send
+
           if multiple
             relate_multi_value method, key, val
           else
@@ -87,15 +88,37 @@ class Card
           end
         end
 
+        private
+
         def relate_multi_value method, key, val
           conj = conjunction(val.first) ? conjunction(val.shift) : :and
-          if conj == current_conjunction
+          if as_list_of_ids?(conj, key, val)
+            relate key, val, multiple: false
+          elsif conj == current_conjunction
             # same conjunction as container, no need for subcondition
-            val.each { |v| send method, key, v }
+            relate_multi_value_without_subcondition method, key, val
           else
-            send conj, (val.map { |v| { key => v } })
+            relate_multi_value_with_subcondition key, conj, val
           end
         end
+
+        def relate_multi_value_with_subcondition key, conj, val
+          send conj, (val.map { |v| { key => v } })
+        end
+
+        def relate_multi_value_without_subcondition method, key, val
+          val.each { |v| send method, key, v }
+        end
+
+        # the #list_of_ids optimization is intended to avoid unnecessary joins and
+        # can probably be applied more broadly, but in the name of caution, we went
+        # with an initial implementation that would only apply to reference attributes
+        # (because reference_query can handle lists of values)
+        def as_list_of_ids? conj, key, val
+          (conj == :or) &&
+            key.to_s.start_with?(/refer|nest|include|link|member/) &&
+            list_of_ids?(val)
+        end
       end
     end
   end

data/lib/card/query/reference_query.rb

@@ -26,8 +26,8 @@ class Card
       def add_outfield_condition outfield, outcard
         if outcard == "_none"
           non_outfield
-        elsif (id = id_from_val(outcard))
-          outfield_id outfield, id
+        elsif (op_and_id = op_and_id_or_ids_from_val(outcard))
+          outfield_id outfield, op_and_id
         else
           tie :card, outcard, from: outfield
         end
@@ -37,8 +37,8 @@ class Card
         add_condition "#{fld :is_present} = 0"
       end
 
-      def outfield_id outfield, id
-        add_condition "#{fld(outfield)} = #{id}"
+      def outfield_id outfield, op_and_id
+        add_condition "#{fld(outfield)} #{op_and_id}"
       end
 
       def add_reftype_condition reftype

data/lib/card/set.rb

@@ -90,7 +90,34 @@ class Card
   #  ...then mycard will include the set modules associated with each of those sets in the
   # above order.
   #
+  # ### Abstract set modules
   #
+  # Suppose you have code that you'd like to reuse in more than one set.
+  #
+  # Well, set modules are just ruby, so it's possible to just define a standard ruby
+  # module (eg `module MySimpleModule...`) in a lib directory and then include that
+  # set (`include MySimpleModule`). That will work just fine so long as you only want
+  # to add simple ruby code and include it in the base ruby module. But what if you
+  # want the reusable code to use the DSL? What if you want to define reusable events,
+  # for example? Or if you want to define reusable views on formats?
+  #
+  # For this purpose, you can use _abstract set modules_. These are modules that use
+  # the set DSL but are not defined directly onto a specific set. Instead, they can
+  # be included in a set using the `include_set` command.
+  #
+  # For example, suppose you create a file at `mod/biz/set/abstract/special_views.rb`.
+  # And within that file you define a view such as the following:
+  #
+  #     format :html do
+  #       view :bizzy do
+  #         "I'm so busy"
+  #       end
+  #     end
+  #
+  # This will create an abstract set that can be included in any other set by invoking
+  # `include_set Card::Set::Abstract::SpecialViews`. Or just `include_set
+  # Abstract::SpecialViews` for short. And then the including set will have access to the
+  # "bizzy" view.
   module Set
     include Event::Api
     include Trait

data/lib/cardio/generators/base.rb

@@ -3,7 +3,7 @@
 module Cardio
   module Generators
     # adds Cardio::Generators::ClassMethods to standard rails generator base class.
-    class Base < ::ActiveRecord::Generators::Base
+    class Base < ::Rails::Generators::Base
       extend ClassMethods
     end
   end

data/lib/cardio/migration/assumption.rb

@@ -0,0 +1,29 @@
+module Cardio
+  class Migration
+    # methods for assuming migration states
+    module Assumption
+      def assume_current
+        context do |mc|
+          versions = mc.migrations.map(&:version)
+          migrated = mc.get_all_versions
+          to_mark = versions - migrated
+          mark_as_migrated to_mark if to_mark.present?
+        end
+      end
+
+      def assume_migrated_upto_version version=nil
+        mode do |_paths|
+          version ||= self.version
+          ActiveRecord::Schema.assume_migrated_upto_version version
+        end
+      end
+
+      private
+
+      def mark_as_migrated versions
+        sql = connection.send :insert_versions_sql, versions
+        connection.execute sql
+      end
+    end
+  end
+end

data/lib/cardio/migration/schema.rb

@@ -0,0 +1,12 @@
+require "cardio/migration"
+
+module Cardio
+  class Migration
+    # for migrations involving database schema definitions
+    class Schema < Migration
+      @migration_type = :schema
+      @old_tables = []
+      @old_deck_table = "schema_migrations_deck"
+    end
+  end
+end

data/lib/cardio/migration/stamp.rb

@@ -0,0 +1,31 @@
+module Cardio
+  class Migration
+    # methods for stamping migration versions to files
+    module Stamp
+      def stamp
+        mode do
+          return unless (version = stampable_version) && (file = stamp_file)
+          puts ">>  writing version: #{version} to #{file.path}"
+          file.puts version
+        end
+      end
+
+      private
+
+      def stamp_file
+        ::File.open stamp_path, "w"
+      end
+
+      def stampable_version
+        version = ActiveRecord::Migrator.current_version
+        version.to_i.positive? && version
+      end
+
+      def stamp_path
+        stamp_dir = ENV["SCHEMA_STAMP_PATH"] || File.join(Cardio.root, "db")
+
+        File.join stamp_dir, "version_#{migration_type}.txt"
+      end
+    end
+  end
+end

data/lib/cardio/migration/transform.rb

@@ -0,0 +1,44 @@
+require "cardio/migration"
+
+module Cardio
+  class Migration
+    # for migrations involving data transformations (but not schema changes)
+    class Transform < Migration
+      include Card::Model::SaveHelper unless ENV["NO_CARD_LOAD"]
+
+      @migration_type = :transform
+      @old_tables = %w[schema_migrations_core_cards schema_migrations_cards]
+      @old_deck_table = "schema_migrations_deck_cards"
+
+      private
+
+      def with_migration_table
+        self.table_name = "transform_migrations"
+        yield
+      ensure
+        self.table_name = "schema_migrations"
+      end
+
+      # Execute this migration in the named direction
+      # override ActiveRecord to wrap 'up' in 'contentedly'
+      def exec_migration conn, direction
+        return super if respond_to? :change
+
+        @connection = conn
+        contentedly { send direction }
+      ensure
+        @connection = nil
+      end
+
+      def contentedly
+        return yield if ENV["NO_CARD_LOAD"]
+        Card::Cache.reset_all
+        Card::Auth.as_bot do
+          yield
+        ensure
+          ::Card::Cache.reset_all
+        end
+      end
+    end
+  end
+end

data/lib/cardio/migration.rb

@@ -2,113 +2,99 @@
 
 module Cardio
   class Migration < ActiveRecord::Migration[6.1]
-    include Card::Model::SaveHelper unless ENV["NO_CARD_LOAD"]
-    @type = :deck_cards
+    include Assumption
+    include Stamp
 
     class << self
-      # Rake tasks use class methods, migrations use instance methods.
-      # To avoid repetition a lot of instance methods here just call class
-      # methods.
-      # The subclass Card::CoreMigration needs a different @type so we can't use a
-      # class variable @@type. It has to be a class instance variable.
-      # Migrations are subclasses of Cardio::Migration or Card::CoreMigration
-      # but they don't inherit the @type. The method below solves this problem.
-      def type
-        @type || ancestors[1]&.type
-      end
+      attr_reader :migration_type, :old_tables, :old_deck_table
 
-      def find_unused_name base_name
-        test_name = base_name
-        add = 1
-        while Card.exists?(test_name)
-          test_name = "#{base_name}#{add}"
-          add += 1
-        end
-        test_name
+      def migration_class type
+        type == :schema ? Migration::Schema : Migration::Transform
       end
 
-      def migration_paths mig_type=type
-        Schema.migration_paths mig_type
+      def new_for type
+        migration_class(type).new
       end
 
-      def schema_suffix mig_type=type
-        Schema.suffix mig_type
+      def port_all
+        %i[schema transform].each do |type|
+          migration_class(type).port
+        end
       end
 
-      def schema_mode mig_type=type, &block
-        Schema.mode mig_type, &block
+      def port
+        return unless connection.table_exists? old_deck_table
+        rename_old_tables
+        connection.execute "INSERT INTO #{table} (SELECT * from #{old_deck_table})"
+        connection.drop_table old_deck_table
       end
 
-      def assume_migrated_upto_version
-        Schema.assume_migrated_upto_version type
-      end
+      private
 
-      def assume_current
-        migration_context do |mc|
-          versions = mc.migrations.map(&:version)
-          migrated = mc.get_all_versions
-          to_mark = versions - migrated
-          mark_as_migrated to_mark if to_mark.present?
+      def rename_old_tables
+        old_tables.each do |old_table_name|
+          next unless connection.table_exists? old_table_name
+          connection.rename_table old_table_name, table
         end
       end
 
-      def data_path filename=nil
-        File.join([migration_paths.first, "data", filename].compact)
-      end
-
-      private
-
-      def mark_as_migrated versions
-        sql = connection.send :insert_versions_sql, versions
-        connection.execute sql
+      def table
+        "#{migration_type}_migrations"
       end
 
       def connection
         ActiveRecord::Base.connection
       end
+    end
 
-      def migration_context &block
-        Schema.migration_context type, &block
-      end
+    def migration_type
+      self.class.migration_type || :schema
     end
 
-    def contentedly
-      return yield if ENV["NO_CARD_LOAD"]
-      Card::Cache.reset_all
-      Schema.mode "" do
-        Card::Auth.as_bot do
-          yield
-        ensure
-          ::Card::Cache.reset_all
-        end
+    def run version=nil, verbose=true
+      context do |mc|
+        ActiveRecord::Migration.verbose = verbose
+        mc.migrate version
       end
     end
 
-    def data_path filename=nil
-      self.class.data_path filename
+    def version
+      path = stamp_path
+      File.exist?(path) ? File.read(path).strip : nil
     end
 
-    # Execute this migration in the named direction
-    # copied from ActiveRecord to wrap 'up' in 'contentedly'
-    def exec_migration conn, direction
-      @connection = conn
-      if respond_to?(:change)
-        if direction == :down
-          revert { change }
-        else
-          change
-        end
-      else
-        contentedly { send(direction) }
+    def migration_paths
+      Cardio.paths["data/#{migration_type}"].existent.to_a
+    end
+
+    def context
+      mode do |paths|
+        yield ActiveRecord::MigrationContext.new(paths, ActiveRecord::SchemaMigration)
       end
-    ensure
-      @connection = nil
+    end
+
+    def mode
+      with_migration_table { yield migration_paths }
     end
 
     def down
       raise ActiveRecord::IrreversibleMigration
     end
+
+    private
+
+    def connection
+      Cardio::Migration.connection
+    end
+
+    def with_migration_table
+      yield
+    end
+
+    def table_name= table_name
+      ActiveRecord::Base.schema_migrations_table_name = table_name
+      ActiveRecord::SchemaMigration.table_name = table_name
+      ActiveRecord::SchemaMigration.reset_column_information
+    end
   end
 end
-
-require "cardio/migration/core"

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

@@ -71,14 +71,20 @@ module Cardio
         end
 
         # for processing that needs to happen on all cards, including fields
-        def each_card_hash items
+        def each_card_hash items, &block
           items.each do |item|
+            raise Card::Error, "inedible pod data: #{item}" unless item.is_a? Hash
+
             yield item
-            item[:fields]&.values&.each { |val| yield val if val.is_a? Hash }
+            process_fields item, &block
           end
           items
         end
 
+        def process_fields item
+          item[:fields]&.values&.each { |val| yield val if val.is_a? Hash }
+        end
+
         def handle_attachments mod, hash
           each_attachment hash do |key, filename|
             hash[key] = mod_file mod, filename

data/lib/cardio/mod/eat.rb

@@ -25,7 +25,6 @@ module Cardio
             track edible do
               current_user edible.delete(:user)
               time_machine edible.delete(:time) do
-                # binding.pry if edible[:type] == :link_list
                 Card.ensure edible
               end
             end
@@ -47,6 +46,8 @@ module Cardio
 
       def track edible
         rescuing edible do
+          # n = edible[:name]
+          # binding.pry if (n.is_a? Array) && n.first.to_s == "main_menu"
           # puts "eating: #{edible}" if @verbose
           card = yield
           puts "eaten: #{card.name}".cyan if @verbose

data/lib/cardio/mod/sow.rb

@@ -114,7 +114,9 @@ module Cardio
       end
 
       def old_data
-        YAML.safe_load File.read(filename), [Symbol] if File.exist? filename
+        return unless File.exist? filename
+        # YAML.safe_load File.read(filename), [Symbol] if File.exist? filename
+        YAML.safe_load File.read(filename), permitted_classes: [Symbol]
       end
 
       # @return Path

data/lib/cardio/mod.rb

@@ -59,9 +59,12 @@ module Cardio
       "mod_#{name}"
     end
 
-    def subpath *parts
+    def subpath *parts, force: false
       path = File.join [@path] + parts
-      path if File.exist? path
+      return path if File.exist? path
+      return unless force
+
+      FileUtils.mkdir_p path
     end
 
     def tmp_dir type

data/lib/cardio/railtie.rb

@@ -65,14 +65,11 @@ module Cardio
 
           p.add "lib/graph_q_l/types/query.rb"
           p.add "mod-data"
+          p.add "data/schema"
+          p.add "data/transform"
 
           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.dirs.each do |mod_path|
             c.autoload_paths += Dir["#{mod_path}/lib"]
@@ -83,7 +80,11 @@ module Cardio
             p["config/initializers"] << "#{mod_path}/config/early"
             p["late/initializers"] << "#{mod_path}/config/late"
             p["lib/tasks"] << "#{mod_path}/lib/tasks"
+
             p["mod-data"] << "#{mod_path}/data"
+            p["data/schema"] << "#{mod_path}/data/schema"
+            p["data/transform"] << "#{mod_path}/data/transform"
+
             p["config/locales"] << "#{mod_path}/config/locales"
           end
 

data/lib/cardio/seed.rb

@@ -2,8 +2,7 @@ module Cardio
   # methods in support of seeding
   module Seed
     TABLES = %w[cards card_actions card_acts card_changes card_references
-                schema_migrations schema_migrations_core_cards
-                schema_migrations_deck schema_migrations_deck_cards].freeze
+                schema_migrations transform_migrations].freeze
 
     class << self
       def default_path
@@ -23,10 +22,8 @@ module Cardio
 
         return unless update_seed?
 
-        Cardio::Migration.assume_current
-        Cardio::Migration::Core.assume_current
-        Cardio::Migration::DeckStructure.assume_current
-        # Cardio::Migration::Core.assume_current
+        Cardio::Migration::Schema.new.assume_current
+        Cardio::Migration::Transform.new.assume_current
       end
 
       def dump