card 1.101.1 → 1.101.6

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

@@ -7,7 +7,7 @@ class Card
           define_method methodname do |val|
             tie :reference,
                 { ref_method => { reftype: reftype, card: val } },
-                to: ref_field
+                { to: ref_field }
           end
         end
 
@@ -33,7 +33,7 @@ class Card
         # DEPRECATE?
 
         def member_of val
-          interpret right_plus: [Card::RolesID, refer_to: val]
+          interpret right_plus: [Card::RolesID, { refer_to: val }]
         end
 
         def member val

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

@@ -74,11 +74,11 @@ class Card
         private
 
         def tie_action action, val
-          tie :action, { action => val }, to: :card_id
+          tie :action, { action => val }, { to: :card_id }
         end
 
         def tie_act action, val
-          tie :act, { action => val }, to: :actor_id
+          tie :act, { action => val }, { to: :actor_id }
         end
 
         def junction val, side, field

data/lib/card/query/join.rb

@@ -58,7 +58,7 @@ class Card
       private
 
       def inside_or?
-        from&.is_a?(Card::Query) && from.mods[:conj] == "or"
+        from.is_a?(Card::Query) && from.mods[:conj] == "or"
       end
 
       # the options :to and :from can be translated into the full table/alias/field trio.

data/lib/card/query/value/match_value.rb

@@ -21,6 +21,7 @@ class Card
 
         def exact_name_match field
           return false unless match_prefix == "=" && field.to_sym == :name
+
           "#{field_sql field} = #{quote match_term.to_name.key}"
         end
 

data/lib/card/reference/all.rb

@@ -0,0 +1,136 @@
+class Card
+  class Reference < ApplicationRecord
+    module All
+      # frozen_string_literal: true
+
+      # Cards can refer to other cards in their content, eg via links and nests.
+      # The card that refers is the "referer", the card that is referred to is
+      # the "referee". The reference itself has its own class (Card::Reference),
+      # which handles id-based reference tracking.
+
+      PARTIAL_REF_CODE = "P".freeze
+
+      # cards that refer to self
+      def referers
+        referer_cards_from_references references_in
+      end
+
+      # cards that include self
+      def nesters
+        referer_cards_from_references references_in.where(ref_type: "I")
+      end
+
+      def referer_cards_from_references references
+        references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
+      end
+
+      # cards that self refers to
+      def referees
+        referees_from_references references_out
+      end
+
+      # cards that self includes
+      def nestees
+        referees_from_references references_out.where(ref_type: "I")
+      end
+
+      def referees_from_references references
+        references.map(&:referee_key).uniq.map { |key| Card.fetch key, new: {} }
+      end
+
+      # cards that refer to self by name
+      # (finds cards not yet linked by id)
+      def name_referers
+        Card.joins(:references_out).where card_references: { referee_key: key }
+      end
+
+      # delete old references from this card's content, create new ones
+      def update_references_out
+        delete_references_out
+        create_references_out
+      end
+
+      # interpret references from this card's content and
+      # insert entries in reference table
+      def create_references_out
+        ref_hash = {}
+        each_reference_out do |referee_name, ref_type|
+          interpret_reference ref_hash, referee_name, ref_type
+        end
+        return if ref_hash.empty?
+
+        Reference.mass_insert reference_values_array(ref_hash)
+      end
+
+      # delete references from this card
+      def delete_references_out
+        raise "id required to delete references" if id.nil?
+
+        Reference.where(referer_id: id).delete_all
+      end
+
+      private
+
+      def with_normalized_referee referee_name
+        return unless referee_name # eg commented nest has no referee_name
+
+        referee_name = referee_name.to_name
+        referee_key = referee_name.key
+        return if referee_key == key # don't create self reference
+
+        yield referee_name, referee_key, Lexicon.id(referee_name)
+      end
+
+      # interpretation phase helps to prevent duplicate references
+      # results in hash like:
+      # { referee1_key: [referee1_id, referee1_type2],
+      #   referee2_key...
+      # }
+      def interpret_reference ref_hash, raw_referee_name, ref_type
+        with_normalized_referee raw_referee_name do |name, key, id|
+          ref_hash[key] ||= [id]
+          ref_hash[key] << ref_type
+          interpret_partial_references ref_hash, name unless id
+        end
+      end
+
+      # translate interpreted reference hash into values array,
+      # removing duplicate and unnecessary ref_types
+      def reference_values_array ref_hash
+        [].tap do |values|
+          ref_hash.each do |referee_key, hash_val|
+            referee_id = hash_val.shift || "null"
+            each_reference_type hash_val.uniq do |ref_type|
+              values << [id, referee_id, "'#{referee_key}'", "'#{ref_type}'"]
+            end
+          end
+        end
+      end
+
+      def each_reference_type ref_types, &block
+        ref_types.delete PARTIAL_REF_CODE if ref_types.size > 1
+        # partial references are not necessary if there are explicit references
+        ref_types.each(&block)
+      end
+
+      # invokes the given block for each reference in content with
+      # the reference name and reference type
+      def each_reference_out
+        content_object.find_chunks(:Reference).each do |chunk|
+          yield chunk.referee_name, chunk.reference_code
+        end
+      end
+
+      # Partial references are needed to track references to virtual cards.
+      # For example a link to virual card [[A+*self]] won't have a referee_id,
+      # but when A's name is changed we have to find and update that link.
+      def interpret_partial_references ref_hash, referee_name
+        return if referee_name.simple?
+
+        [referee_name.left, referee_name.right].each do |sidename|
+          interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
+        end
+      end
+    end
+  end
+end

data/lib/card/rule/all.rb

@@ -0,0 +1,76 @@
+class Card
+  module Rule
+    # rule-related Card instance methods
+    module All
+      def rule setting_code
+        rule_card(setting_code, skip_modules: true)&.db_content
+      end
+
+      def rule_card setting_code, options={}
+        Card.fetch rule_card_id(setting_code), options
+      end
+
+      def rule_card_id setting_code
+        rule_id_lookup Card::Rule.rule_cache, setting_code
+      end
+
+      def preference setting_code, user=nil
+        preference_card(setting_code, user, skip_modules: true)&.db_content
+      end
+
+      def preference_card setting_code, user=nil, options={}
+        Card.fetch preference_card_id(setting_code, user), options
+      end
+
+      def preference_card_id setting_code, user=nil
+        return unless (user_id = preference_user_id user)
+
+        rule_id_lookup Card::Rule.preference_cache,
+                       "#{setting_code}+#{user_id}",
+                       "#{setting_code}+#{AllID}"
+      end
+
+      def rule?
+        standard_rule? || preference?
+      end
+
+      def standard_rule?
+        (Card.fetch_type_id(name.right) == SettingID) &&
+          (Card.fetch_type_id(name.left) == SetID)
+      end
+
+      def preference?
+        name.parts.length > 2 &&
+          (Card.fetch_type_id(name.right) == SettingID) &&
+          (Card.fetch_type_id(name[0..-3]) == SetID) &&
+          valid_preferer?
+      end
+
+      private
+
+      def valid_preferer?
+        preferer = self[-2, skip_modules: true]
+        (preferer.type_id == UserID) || (preferer.codename == :all)
+      end
+
+      def preference_user_id user
+        case user
+        when Integer then user
+        when Card    then user.id
+        when nil     then Auth.current_id
+        else
+          raise Card::ServerError, "invalid preference user"
+        end
+      end
+
+      def rule_id_lookup lookup_hash, cache_suffix, fallback_suffix=nil
+        rule_set_keys.each do |rule_set_key|
+          rule_id = lookup_hash["#{rule_set_key}+#{cache_suffix}"]
+          rule_id ||= fallback_suffix && lookup_hash["#{rule_set_key}+#{fallback_suffix}"]
+          return rule_id if rule_id
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/card/rule/cache.rb

@@ -39,12 +39,14 @@ class Card
         def lookup_hash
           rows.each_with_object({}) do |row, hash|
             next unless (key = lookup_key row)
+
             hash[key] = row["rule_id"].to_i
           end
         end
 
         def lookup_key row
           return false unless (setting_code = setting_code(row))
+
           anchor_id = row["anchor_id"]
           return false unless (pattern_code = pattern_code(anchor_id, row))
 

data/lib/card/set/advanced_api.rb

@@ -10,8 +10,8 @@ class Card
       def ensure_set &block
         set_module = yield
         set_module = card_set_module_const_get(set_module) unless set_module.is_a?(Module)
-      rescue NameError => error
-        define_set_from_error error
+      rescue NameError => e
+        define_set_from_error e
         # try again - there might be another submodule that doesn't exist
         ensure_set(&block)
       else
@@ -21,6 +21,7 @@ class Card
       def define_set_from_error error
         match = error.message.match(/uninitialized constant (?:Card::Set::)?(.+)$/)
         return unless match
+
         define_set match[1]
       end
 
@@ -29,8 +30,7 @@ class Card
         add_attributes name, "remote_#{name}_url".to_sym,
                        :action_id_of_cached_upload, :empty_ok,
                        :storage_type, :bucket, :mod
-        uploader_class = args[:uploader] || ::CarrierWave::FileCardUploader
-        mount_uploader name, uploader_class
+        mount_uploader name, (args[:uploader] || ::CarrierWave::FileCardUploader)
         Card.define_dirty_methods name
       end
 

data/lib/card/set/event.rb

@@ -70,7 +70,7 @@ class Card
         # @option opts [Symbol] :stage alternate representation for specifying stage
         # @option opts [True/False] :after_subcards run event after running subcard events
         def event event, stage_or_opts={}, opts={}, &final
-          Event.new(event, stage_or_opts, opts, self, &final).register
+          Event.new(event, self).register stage_or_opts, opts, &final
         end
       end
 
@@ -82,15 +82,19 @@ class Card
 
       attr_reader :set_module, :opts
 
-      def initialize event, stage_or_opts, opts, set_module, &final
+      def initialize event, set_module
         @event = event
         @set_module = set_module
+      end
+
+      def register stage_or_opts, opts, &final
         @opts = event_opts stage_or_opts, opts
         @event_block = final
+        validate_conditions
+        define
       end
 
-      def register
-        validate_conditions
+      def define
         Card.define_callbacks @event
         define_event
         set_event_callbacks
@@ -156,8 +160,8 @@ class Card
     end
   end
 
-  def rescuing_if_integration is_integration
-    is_integration ? rescuing_integration { yield } : yield
+  def rescuing_if_integration is_integration, &block
+    is_integration ? rescuing_integration(&block) : yield
   end
 
   # one failed integration event should not harm others.

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

@@ -0,0 +1,101 @@
+class Card
+  module Set
+    class Event
+      # card methods for testing event applicability
+      module All
+        include SkipAndTrigger
+
+        def event_applies? event
+          return unless set_condition_applies? event.set_module, event.opts[:changing]
+
+          CONDITIONS.all? { |c| send "#{c}_condition_applies?", event, event.opts[c] }
+        end
+
+        private
+
+        def set_condition_applies? set_module, old_sets
+          return true if set_module == Card
+
+          set_condition_card(old_sets).singleton_class.include? set_module
+        end
+
+        def on_condition_applies? _event, actions
+          actions = Array(actions).compact
+          actions.empty? ? true : actions.include?(action)
+        end
+
+        # if changing name/type, the old card has no-longer-applicable set modules,
+        # so we create a new card to determine whether events apply.
+        # (note: cached condition card would ideally be cleared after all
+        # conditions are reviewed)
+        # @param old_sets [True/False] whether to use the old_sets
+        def set_condition_card old_sets
+          return self if old_sets || no_current_action?
+
+          @set_condition_card ||=
+            updating_sets? ? set_condition_card_with_new_set_modules : self
+        end
+
+        # existing card is being changed in a way that alters its sets
+        def updating_sets?
+          action == :update && real? && (type_id_is_changing? || name_is_changing?)
+        end
+
+        # prevents locking in set_condition_card
+        def no_current_action?
+          return false if @current_action
+
+          @set_condition_card = nil
+          true
+        end
+
+        def set_condition_card_with_new_set_modules
+          cc = Card.find id
+          cc.name = name
+          cc.type_id = type_id
+          cc.include_set_modules
+        end
+
+        def changed_condition_applies? _event, db_columns
+          return true unless action == :update
+
+          db_columns = Array(db_columns).compact
+          return true if db_columns.empty?
+
+          db_columns.any? { |col| single_changed_condition_applies? col }
+        end
+        alias_method :changing_condition_applies?, :changed_condition_applies?
+
+        def when_condition_applies? _event, block
+          case block
+          when Proc then block.call(self)
+          when Symbol then send block
+          else true
+          end
+        end
+
+        def single_changed_condition_applies? db_column
+          return true unless db_column
+
+          send "#{db_column}_is_changing?"
+        end
+
+        def wrong_stage opts
+          return false if director.stage_ok? opts
+
+          if !stage
+            "phase method #{method} called outside of event phases"
+          else
+            "#{opts.inspect} method #{method} called in stage #{stage}"
+          end
+        end
+
+        def wrong_action actn
+          return false if on_condition_applies?(nil, actn)
+
+          "on: #{actn} method #{method} called on #{action}"
+        end
+      end
+    end
+  end
+end