card 1.92.2 → 1.93.0

data/lib/card/migration/import/import_data.rb

@@ -37,10 +37,11 @@ class Card
         end
 
         def select_cards names_or_keys
-          cards.map do |attributes|
-            next unless name_or_key_match attributes, names_or_keys
+          names_or_keys.map do |key|
+            attributes = find_card_attributes(key)
+            raise("no entry for #{key} (key: #{key.to_name.key}) in #{@path}") unless attributes
             prepare_for_import attributes
-          end.compact
+          end
         end
 
         def changed_cards
@@ -70,8 +71,7 @@ class Card
         end
 
         def url remote_name
-          remotes[remote_name.to_sym] ||
-            raise("unknown remote: #{remote_name}")
+          remotes[remote_name.to_sym] || raise("unknown remote: #{remote_name}")
         end
 
         private
@@ -85,13 +85,6 @@ class Card
           [card_data, data[:content]]
         end
 
-        def name_or_key_match attributes, names_or_keys
-          names_or_keys.any? do |nk|
-            nk == attributes[:name] || nk == attributes[:name].to_name.key ||
-              nk == attributes[:key]
-          end
-        end
-
         def remotes
           @data[:remotes]
         end

data/lib/card/migration/import/import_data/card_attributes.rb

@@ -37,10 +37,9 @@ class Card
 
          def find_card_attributes name
            key = name.to_name.key
-           index = cards.find_index { |attr| attr[:key] == key } ||
-             cards.find_index { |attr| attr[:name] == name }
-           return unless index
-           cards[index]
+           cards.find do |attr|
+             key == (attr[:key].present? ? attr[:key] : attr[:name].to_name.key)
+           end
          end
 
          private

data/lib/card/mod.rb

@@ -34,8 +34,9 @@ class Card
   #
   # Learn more:
   #   - {Card} introduces card objects
-  #   - {Card::Set} provides an overview of the set module API
-  #   - {Card::View} explains the basics of the view API
+  #   - {Card::Set} provides an overview of how set modules work
+  #   - {Card::Format} explains the basics of the view API
+  #   - {Card::Set::Event} explains the basics of the event API
   #
   # ## Other Directories
   #
@@ -48,7 +49,7 @@ class Card
   #   - **file** for any other supporting files
   #
 
-module Mod
+  module Mod
     class << self
       def load
         Loader.load_mods

data/lib/card/mod/dirs.rb

@@ -27,9 +27,14 @@ class Card
     # in load order with a preceding "mod" command (similar to a Gemfile).
     # The mods are expected in subdirectories with the mod names.
     #
+    # Mods in Modfiles are always loaded before mods in the Gemfile.
+    # If you have to change the order add gem mods to your Modfile using the
+    # mod_gem command. You can omit the 'card-mod' prefix.
+    #
     # Example for a mod directory:
     #   # my_mod/Modfile
     #   mod "twitter"
+    #   gem_mod "logger"
     #   mod "cache"
     #
     #   # directory structure
@@ -54,6 +59,7 @@ class Card
       # @param mod_paths [String, Array<String>] paths to directories that contain mods
       def initialize mod_paths=[]
         @mods = []
+        @loaded_gem_mods = ::Set.new
         @paths = {}
         mod_paths = Array(mod_paths)
         mod_paths.each do |mp|
@@ -78,6 +84,18 @@ class Card
         @paths[mod_name] = path
       end
 
+      def gem_mod mod_name, path=nil
+        path ||= Cardio.gem_mod_paths[mod_name]
+        raise Error, "Unknown gem mod \"#{mod_name}\". Make sure it is in your Gemfile." unless path
+        add_gem_mod mod_name, path
+      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
+      end
+
       alias_method :mod, :add_path
 
       # @param mod_name [String] the name of a mod
@@ -129,16 +147,9 @@ class Card
       end
 
       def load_from_gemfile
-        Bundler.definition.specs.map do |s|
-          mod_name =
-            if s.name =~ /^decko-mod-(.+)$/
-              $1
-            else
-              s.metadata["card-mod"]
-            end
-          next unless mod_name
-          add_path $1, s.full_gem_path
-        end.compact
+        Cardio.gem_mod_paths.each do |mod_name, mod_path|
+          add_gem_mod mod_name, mod_path
+        end
       end
 
       def tmp_dir modname, type

data/lib/card/mod/loader.rb

@@ -40,10 +40,10 @@ class Card
         attr_reader :module_type
 
         def load_mods
-          load_initializers
           SetPatternLoader.new.load
           load_formats
           SetLoader.new.load
+          load_initializers
         end
 
         def load_chunks

data/lib/card/model/save_helper.rb

@@ -102,7 +102,7 @@ class Card
       end
 
       def validate_setting setting
-        unless Card::Codename[setting] &&
+        unless Card::Codename.exist?(setting) &&
                Card.fetch_type_id(setting) == SettingID
           raise ArgumentError, "not a valid setting: #{setting}"
         end

data/lib/card/name.rb

@@ -16,16 +16,18 @@ class Card
     self.session = proc { Card::Auth.current.name } # also_yuck
 
     class << self
-      def cardish mark
-        case mark
-        when Card            then mark.cardname
-        when Symbol, Integer then Card.quick_fetch(mark).cardname
-        else                      mark.to_name
+      def [] *cardish
+        cardish = cardish.first if cardish.size <= 1
+        case cardish
+        when Card            then cardish.name
+        when Symbol, Integer then Card.fetch_name(cardish)
+        when Array           then compose cardish
+        else                      cardish.to_name
         end
       end
 
       def compose parts
-        parts.flatten.map { |part| cardish part }.join joint
+        new parts.flatten.map { |part| self[part] }.join(joint)
       end
 
       def url_key_to_standard key

data/lib/card/name/fields_and_traits.rb

@@ -49,20 +49,15 @@ class Card
 
       # @return [Card::Name]
       def trait_name tag_code
-        card_id = Card::Codename[tag_code]
-        raise Card::Error::NotFound, "unknown codename: #{tag_code}" unless card_id
-        [self, Card.quick_fetch(card_id).name].to_name
+        Card::Name[self, tag_code.to_sym]
       end
 
       # @return [True/False]
       def trait_name? *traitlist
-        junction? && begin
-          right_key = right_name.key
-          traitlist.find do |codename|
-            (card_id = Card::Codename[codename]) &&
-              (card = Card.quick_fetch card_id) &&
-              card.key == right_key
-          end.present?
+        return false unless junction?
+        right_key = right_name.key
+        traitlist.any? do |codename|
+          Codename.name(codename)&.key == right_key
         end
       end
     end

data/lib/card/query.rb

@@ -7,7 +7,7 @@ class Card
   # frequently used directly in code.
   #
   # Query "statements" (objects, really) are made in WQL (Wagn Query
-  # Language). Because WQL is used by Wagneers, the primary language
+  # Language). Because WQL is used by Deckers, the primary language
   # documentation is on wagn.org. (http://wagn.org/WQL_Syntax). Note that the
   # examples there are in JSON, like Search card content, but statements in
   # Card::Query are in ruby form.

data/lib/card/reference.rb

@@ -43,7 +43,7 @@ class Card
           "cards.id IS NULL"
         ).pluck_in_batches(:id) do |group_ids|
           # used to be .delete_all here, but that was failing on large dbs
-          puts "deleting batch of references"
+          Rails.logger.info "deleting batch of references"
           where("id in (#{group_ids.join ','})").delete_all
         end
       end

data/lib/card/set.rb

@@ -15,12 +15,9 @@ class Card
   #
   #      ./contactmanager/set/right/address.rb
   #
-  #  Then, whenever you fetch or instantiate a +address card, the card will
-  #  automatically include code from that set module.  In fact, it will include
-  #  all the set modules associated with sets of which it is a member.
+  #  Then, whenever you fetch or instantiate a +address card, the card will automatically include code from that set module.  In fact, it will include all the set modules associated with sets of which it is a member.
   #
-  #  For example, say you have a Plaintext card named 'Philipp+address', and
-  #  you have set files for the following sets:
+  #  For example, say you have a Plaintext card named 'Philipp+address', and you have set files for the following sets:
   #
   #      * all cards
   #      * all Plaintext cards
@@ -30,17 +27,13 @@ class Card
   #
   #      mycard = Card.fetch 'Philipp+address'
   #
-  #  ...then mycard will include the set modules associated with each of those
-  #  sets in the above order.
+  #  ...then mycard will include the set modules associated with each of those sets in the above order.
   #
-  #  Note that the set module's filename connects it to the set, so both
-  #  the set_pattern and the set_anchor must correspond to the
-  #  codename of a card in the database to function correctly.
+  #  Note that the set module's filename connects it to the set, so both the set_pattern and the set_anchor must correspond to the codename of a card in the database to function correctly.
   #
-  #  A set module is "just ruby", but is generally quite concise because
-  #  Card (a) uses its the set module's file location to autogenerate ruby
-  #  module names and (b) then uses Card::Set module to provide API for the
-  #  most common set methods.
+  #  A set module is "just ruby", but is generally quite concise because Card
+  #        a) uses its the set module's file location to autogenerate ruby module names and
+  #        b) then uses Card::Set module to provide API for the most common set methods.
   #
   module Set
     include Event

data/lib/card/set/advanced_api.rb

@@ -23,6 +23,7 @@ class Card
                        :storage_type, :bucket, :mod
         uploader_class = args[:uploader] || ::CarrierWave::FileCardUploader
         mount_uploader name, uploader_class
+        Card.define_dirty_methods name
       end
 
       def stage_method method, opts={}, &block

data/lib/card/set/event.rb

@@ -1,76 +1,16 @@
 class Card
-  def deserialize_for_active_job! attr
-    attr.each do |attname, val|
-      instance_variable_set("@#{attname}", val)
-    end
-
-    include_set_modules
-  end
-
-  def with_env_and_auth env, auth
-    # If active jobs (and hence the integrate_with_delay events) don't run
-    # in a background process then Card::Env.deserialize! decouples the
-    # controller's params hash and the Card::Env's params hash with the
-    # effect that params changes in the CardController get lost
-    # (a crucial example are success params that are processed in
-    # CardController#update_params_for_success)
-    return yield if Decko.config.active_job.queue_adapter == :inline
-    Card::Auth.with auth do
-      Card::Env.with env do
-        yield
-      end
-    end
-  end
-
-  def serialize_for_active_job
-    serializable_attributes.each_with_object({}) do |name, hash|
-      hash[name] = instance_variable_get("@#{name}")
-    end
-  end
-
-  def serialize_value value
-    # ActiveJob doesn't accept symbols and Time as arguments
-    case value
-    when Symbol
-      { value: value.to_s, type: "symbol" }
-    when Time
-      { value: value.to_s, type: "time" }
-    when Hash
-      {
-        value: value.each_with_object({}) { |(k, v), h| h[k] = serialize_value(v) },
-        type: "hash"
-      }
-    when ActionController::Parameters
-      serialize_value value.to_unsafe_h
-    else
-      { value: value }
-    end
-  end
-
-  def deserialize_value val, type
-    case type
-    when "symbol"
-      val.to_sym
-    when "time"
-      DateTime.parse val
-    when "hash"
-      val.each_with_object({}) do |(k, v), h|
-        h[k] = deserialize_value v[:value], v[:type]
-      end
-    else
-      val
-    end
-  end
-
-  def log_event_call event
-    Rails.logger.debug "#{name}: #{event}"
-    # puts "#{name}: #{event}"
-    # puts "#{Card::ActManager.to_s}".green
-  end
-
   module Set
-    # Implements the event API for card sets
+    # Events are the building blocks of the three transformative card actions: _create_, _update_, and _delete_. (The fourth kind of action, _read_, does not transform cards, and is associated with {Card::Format views}, not events).
+    #
+    # Whenever you create, update, or delete a card, the card goes through three phases:
+    #   * __validation__ makes sure all the data is in order
+    #   * __storage__ puts the data in the database
+    #   * __integration__ deals with any ramifications of those changes
+    #
+    #
     module Event
+      include DelayedEvent
+
       def event event, stage_or_opts={}, opts={}, &final
         if stage_or_opts.is_a? Symbol
           opts[:in] = stage_or_opts
@@ -93,16 +33,10 @@ class Card
         end
 
         if with_delay? opts
-          delaying_method = "#{event}_with_delay"
-          define_event_delaying_method event, delaying_method, final_method_name
-          final_method_name = delaying_method
+          define_delayed_event_method event, final_method_name
+        else
+          define_event_method event, final_method_name
         end
-        define_event_method event, final_method_name
-      end
-
-      def with_delay? opts
-        opts[:after] == :integrate_with_delay_stage ||
-          opts[:before] == :integrate_with_delay_stage
       end
 
       def process_stage_opts opts
@@ -131,36 +65,6 @@ class Card
         end
       end
 
-      # creates an ActiveJob.
-      # The scheduled job gets the card object as argument and all serializable
-      # attributes of the card.
-      # (when the job is executed ActiveJob fetches the card from the database
-      # so all attributes get lost)
-      # @param event [String] the event used as queue name
-      # @param method_name [String] the name of the method we define to trigger
-      #   the actjve job
-      # @param final_method_name [String] the name of the method that get called
-      #   by the active job and finally executes the event
-      def define_event_delaying_method event, method_name, final_method_name
-        class_eval do
-          define_method(method_name, proc do
-            IntegrateWithDelayJob.set(queue: event).perform_later(
-              self, serialize_for_active_job, Card::Env.serialize,
-              Card::Auth.serialize, final_method_name
-            )
-          end)
-        end
-      end
-
-      class IntegrateWithDelayJob < ApplicationJob
-        def perform card, card_attribs, env, auth, method_name
-          card.deserialize_for_active_job! card_attribs
-          card.with_env_and_auth env, auth do
-            card.send method_name
-          end
-        end
-      end
-
       def set_event_callbacks event, opts
         opts[:set] ||= self
         [:before, :after, :around].each do |kind|
@@ -175,4 +79,10 @@ class Card
       end
     end
   end
+
+  def log_event_call event
+    Rails.logger.debug "#{name}: #{event}"
+    # puts "#{name}: #{event}"
+    # puts "#{Card::ActManager.to_s}".green
+  end
 end

data/lib/card/set/event/delayed_event.rb

@@ -0,0 +1,104 @@
+class Card
+  module Set
+    module Event
+      module DelayedEvent
+        DELAY_STAGES = ::Set.new([:integrate_with_delay_stage,
+                                  :integrate_with_delay_final_stage]).freeze
+
+        private
+
+        def with_delay? opts
+          DELAY_STAGES.include?(opts[:after]) || DELAY_STAGES.include?(opts[:before])
+        end
+
+        def define_delayed_event_method event, final_method_name
+          delaying_method = "#{event}_with_delay"
+          define_event_delaying_method event, delaying_method, final_method_name
+          define_event_method event, delaying_method
+        end
+
+        # creates an ActiveJob.
+        # The scheduled job gets the card object as argument and all serializable
+        # attributes of the card.
+        # (when the job is executed ActiveJob fetches the card from the database
+        # so all attributes get lost)
+        # @param event [String] the event used as queue name
+        # @param method_name [String] the name of the method we define to trigger
+        #   the actjve job
+        # @param final_method_name [String] the name of the method that get called
+        #   by the active job and finally executes the event
+        def define_event_delaying_method event, method_name, final_method_name
+          class_eval do
+            define_method(method_name, proc do
+              IntegrateWithDelayJob.set(queue: event).perform_later(
+                Card::ActManager.act&.id, self, serialize_for_active_job, Card::Env.serialize,
+                Card::Auth.serialize, final_method_name
+              )
+            end)
+          end
+        end
+
+        class IntegrateWithDelayJob < ApplicationJob
+          def perform act_id, card, card_attribs, env, auth, method_name
+            card.deserialize_for_active_job! card_attribs
+            ActManager.contextualize_delayed_event act_id, card, env, auth do
+              card.send method_name
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def deserialize_for_active_job! attr
+    attr.each do |attname, val|
+      instance_variable_set("@#{attname}", val)
+    end
+    include_set_modules
+  end
+
+  def serialize_for_active_job
+    serializable_attributes.each_with_object({}) do |name, hash|
+      hash[name] = instance_variable_get("@#{name}")
+    end
+  end
+
+  def serialize_value value
+    # ActiveJob doesn't accept symbols and Time as arguments
+    case value
+    when Symbol
+      { value: value.to_s, type: "symbol" }
+    when Time
+      { value: value.to_s, type: "time" }
+    when Hash
+      { value: serialize_hash_value(value), type: "hash"}
+    when ActionController::Parameters
+      serialize_value value.to_unsafe_h
+    else
+      { value: value }
+    end
+  end
+
+  def serialize_hash_value
+    value.each_with_object({}) { |(k, v), h| h[k] = serialize_value(v) }
+  end
+
+  def deserialize_value val, type
+    case type
+    when "symbol"
+      val.to_sym
+    when "time"
+      DateTime.parse val
+    when "hash"
+      deserialize_hash_value val
+    else
+      val
+    end
+  end
+
+  def deserialize_hash_value value
+    value.each_with_object({}) do |(k, v), h|
+      h[k] = deserialize_value v[:value], v[:type]
+    end
+  end
+end