card 1.99.2 → 1.100.0

data/lib/card/director/store.rb

@@ -0,0 +1,73 @@
+class Card
+  class Director
+    # Special handling specific to the :store stage
+    module Store
+      def after_store &block
+        @after_store ||= []
+        @after_store << block
+      end
+
+      protected
+
+      def after_store?
+        @after_store.present?
+      end
+
+      private
+
+      # The tricky part here is to preserve the dirty marks on the subcards'
+      # attributes for the finalize stage.
+      # To achieve this we can't just call the :store and :finalize callbacks on
+      # the subcards as we do in the other phases.
+      # Instead we have to call `save` on the subcards
+      # and use the ActiveRecord :around_save callback to run the :store and
+      # :finalize stages
+      def store &save_block
+        raise Card::Error, "need block to store main card" if main? && !block_given?
+
+        # the block is the ActiveRecord block from the around save callback that
+        # saves the card
+        if block_given?
+          run_stage_callbacks :store
+          store_with_subcards(&save_block)
+        else
+          trigger_storage_phase_callback
+        end
+      end
+
+      def store_with_subcards
+        store_pre_subcards # the exception!  usually does nothing
+        yield
+        run_after_store_callbacks if after_store?
+        store_post_subcards # the typical case
+        true
+      ensure
+        @card.handle_subcard_errors
+      end
+
+      def run_after_store_callbacks
+        @after_store.each { |block| block.call @card }
+      end
+
+      # If the subcard has an after-store callback, it means the subcard
+      # must run before the supercard and then call back
+      def store_pre_subcards
+        run_subcard_stages :store, &:after_store?
+      end
+
+      def store_post_subcards
+        run_subcard_stages(:store) { |subdir| !subdir.after_store? }
+      end
+
+      # trigger the storage_phase, skip the other phases
+      # At this point the :prepare_to_store stage was already executed
+      # by the parent director. So the storage phase will only run
+      # the :store stage and the :finalize stage
+      def trigger_storage_phase_callback
+        @stage = stage_index :prepare_to_store
+        @only_storage_phase = true
+        @card.save! validate: false
+      end
+    end
+  end
+end

data/lib/card/{act_manager → director}/subdirector_array.rb

@@ -1,5 +1,5 @@
 class Card
-  class ActManager
+  class Director
     class SubdirectorArray < Array
       def self.initialize_with_subcards parent
         dir_array = new(parent)
@@ -14,31 +14,37 @@ class Card
         super()
       end
 
-      def add card, opts={}
-        opts ||= {}
-        card = card.card if card.is_a? StageDirector
-        each { |dir| return dir if dir.card == card }
-        dir = ActManager.fetch card, parent: @parent
-        dir.replace_card card if dir.card != card
-        dir.main = false
-        dir.parent = @parent
-        dir.transact_in_stage = opts[:transact_in_stage]
-        self << dir
-        dir
+      def add card
+        card = card.card if card.is_a? Director
+        existing(card) || fetch_new(card)
       end
 
       alias_method :delete_director, :delete
 
       def delete card
-        if card.is_a? StageDirector
+        if card.is_a? Director
           delete_director card
         else
           delete_if { |dir| dir.card == card }
         end
       end
 
-      def add_director dir
-        add dir.card
+      private
+
+      def existing card
+        find { |dir| dir.card == card }
+      end
+
+      def fetch_new card
+        Director.fetch(card, @parent).tap do |dir|
+          update dir, card unless dir.main?
+        end
+      end
+
+      def update dir, card
+        dir.replace_card card if dir.card != card
+        dir.parent = @parent
+        self << dir
       end
     end
   end

data/lib/card/dirty.rb

@@ -1,11 +1,25 @@
 class Card
+  # Special "dirty" handling for significant card fields.
   module Dirty
     extend ::Card::Dirty::MethodFactory
 
-    %i[name db_content trash type_id].each do |field|
-      define_dirty_methods field
+    class << self
+      def dirty_fields
+        %i[name db_content trash type_id left_id right_id codename]
+      end
+
+      def dirty_aliases
+        { type: :type_id, content: :db_content }
+      end
+
+      def dirty_options
+        dirty_fields + dirty_aliases.keys
+      end
     end
 
+    dirty_fields.each { |field| define_dirty_methods field }
+    dirty_aliases.each { |k, v| alias_method "#{k}_is_changing?", "#{v}_is_changing?" }
+
     def attribute_before_act attr
       if saved_change_to_attribute? attr
         attribute_before_last_save attr
@@ -32,4 +46,25 @@ class Card
       end
     end
   end
+
+  # Even special-er handling for dirty cardnames
+  module DirtyNames
+    def name_is_changing?
+      super || left_id_is_changing? || right_id_is_changing?
+    end
+
+    # def name_before_last_save
+    #   super || dirty_name(left_id_before_last_save, right_id_before_last_save)
+    # end
+
+    def name_before_act
+      super || dirty_name(left_id_before_act, right_id_before_act)
+    end
+
+    def dirty_name left, right
+      return unless left.present? && right.present?
+
+      Card::Name[left, right]
+    end
+  end
 end

data/lib/card/env.rb

@@ -5,10 +5,9 @@ class Card
   # Env can differ for each request; Card.config should not.
   module Env
     extend LocationHistory
-
-    SERIALIZABLE_ATTRIBUTES = ::Set.new %i[
-      main_name params ip ajax html host protocol salt
-    ]
+    extend RequestAssignments
+    extend SlotOptions
+    extend Serialization
 
     class << self
       def reset args={}
@@ -38,13 +37,19 @@ class Card
         self[:params] ||= {}
       end
 
-      def slot_opts
-        # FIXME:  upgrade to safe parameters
-        self[:slot_opts] ||= begin
-          opts = params[:slot]&.clone || {}
-          opts = opts.to_unsafe_h if opts.is_a? ActionController::Parameters
-          opts.merge! shortcut_slot_opts
-          opts.deep_symbolize_keys.slice(*Card::View::Options.slot_keys)
+      def with_params hash
+        old_params = params.clone
+        params.merge! hash
+        yield
+      ensure
+        self.params = old_params
+      end
+
+      def hash hashish
+        case hashish
+        when Hash then hashish.clone
+        when ActionController::Parameters then hashish.to_unsafe_h
+        else {}
         end
       end
 
@@ -65,7 +70,7 @@ class Card
       end
 
       def localhost?
-        self[:host] && self[:host] =~ /^localhost/
+        self[:host]&.match?(/^localhost/)
       end
 
       def ajax?
@@ -76,38 +81,8 @@ class Card
         !self[:controller] || self[:html]
       end
 
-      def serialize
-        @env.select { |k, _v| SERIALIZABLE_ATTRIBUTES.include?(k) }
-      end
-
-      # @param serialized_env [Hash]
-      def with serialized_env
-        tmp_env = serialize if @env
-        @env ||= {}
-        @env.update serialized_env
-        yield
-      ensure
-        @env.update tmp_env if tmp_env
-      end
-
       private
 
-      def assign_ajax c
-        c.request.xhr? || c.request.params[:simulate_xhr]
-      end
-
-      def assign_html c
-        [nil, "html"].member?(c.params[:format])
-      end
-
-      def assign_host c
-        Card.config.override_host || c.request.env["HTTP_HOST"]
-      end
-
-      def assign_protocol c
-        Card.config.override_protocol || c.request.protocol
-      end
-
       def method_missing method_id, *args
         case args.length
         when 0 then self[method_id]
@@ -115,17 +90,6 @@ class Card
         else super
         end
       end
-
-      def shortcut_slot_opts
-        opts = {}
-        opts[:size] = params[:size].to_sym if params[:size]
-        opts[:items] = { view: params[:item].to_sym } if slot_items_shortcut?
-        opts
-      end
-
-      def slot_items_shortcut?
-        params[:item].present? && !params.dig(:slot, :items, :view).present?
-      end
     end
   end
 end

data/lib/card/env/location.rb

@@ -21,10 +21,24 @@ class Card
       end
 
       def protocol_and_host
-        Card.config.protocol_and_host || "#{Card::Env[:protocol]}#{Card::Env[:host]}"
+        Card.config.protocol_and_host || "#{Env[:protocol]}#{Env[:host]}"
       end
 
-      extend Location # ??
+      def cardname_from_url url
+        return unless (cardname = cardname_from_url_regexp)
+        m = url.match cardname
+        m ? Card::Name[m[:mark]] : nil
+      end
+
+      private
+
+      def cardname_from_url_regexp
+        return unless Env[:host]
+
+        %r{#{Regexp.escape Env[:host]}/(?<mark>[^\?]+)}
+      end
+
+      extend Location # allows calls on Location constant, eg Location.card_url
     end
   end
 end

data/lib/card/env/request_assignments.rb

@@ -0,0 +1,24 @@
+class Card
+  module Env
+    # environmental variables assigned based on request
+    module RequestAssignments
+      private
+
+      def assign_ajax c
+        c.request.xhr? || c.request.params[:simulate_xhr]
+      end
+
+      def assign_html c
+        [nil, "html"].member?(c.params[:format])
+      end
+
+      def assign_host c
+        Card.config.override_host || c.request.env["HTTP_HOST"]
+      end
+
+      def assign_protocol c
+        Card.config.override_protocol || c.request.protocol
+      end
+    end
+  end
+end

data/lib/card/env/serialization.rb

@@ -0,0 +1,24 @@
+class Card
+  module Env
+    # serializing environment (eg for delayed jobs)
+    module Serialization
+      SERIALIZABLE_ATTRIBUTES = ::Set.new %i[
+        main_name params ip ajax html host protocol salt
+      ]
+
+      # @param serialized_env [Hash]
+      def with serialized_env
+        tmp_env = serialize if @env
+        @env ||= {}
+        @env.update serialized_env
+        yield
+      ensure
+        @env.update tmp_env if tmp_env
+      end
+
+      def serialize
+        @env.select { |k, _v| SERIALIZABLE_ATTRIBUTES.include?(k) }
+      end
+    end
+  end
+end

data/lib/card/env/slot_options.rb

@@ -0,0 +1,30 @@
+class Card
+  module Env
+    # slot-related environmental variable handling
+    module SlotOptions
+      def slot_opts
+        # FIXME:  upgrade to safe parameters
+        self[:slot_opts] ||= interpret_slot_options
+      end
+
+      private
+
+      def interpret_slot_options
+        opts = hash params[:slot]
+        opts.merge! shortcut_slot_opts
+        opts.deep_symbolize_keys.slice(*Card::View::Options.slot_keys)
+      end
+
+      def shortcut_slot_opts
+        opts = {}
+        opts[:size] = params[:size].to_sym if params[:size]
+        opts[:items] = { view: params[:item].to_sym } if slot_items_shortcut?
+        opts
+      end
+
+      def slot_items_shortcut?
+        params[:item].present? && !params.dig(:slot, :items, :view).present?
+      end
+    end
+  end
+end

data/lib/card/env/success.rb

@@ -101,7 +101,7 @@ class Card
         if @card
           @card
         elsif @id
-          Card.find @id
+          Card.fetch @id
         elsif @name
           Card.fetch @name.to_name.absolute(name_context), new: @new_args
         end

data/lib/card/format.rb

@@ -6,7 +6,7 @@ class Card
   # are responsible for defining and rendering _views_.
   #
   # However, monkeys (those who code in the Card/Decko framework) rarely write code
-  # directly in these classes. Instead they organize their code using {Card::Mods mods}.
+  # directly in these classes. Instead they organize their code using {Card::Mod mods}.
   #
   # {Card::Mod} explains how to set up a mod.
   # {Card::Set::Format} explains how to use this and other format classes within a mod.
@@ -94,6 +94,10 @@ class Card
       "text/plain"
     end
 
+    def escape_literal literal
+      literal
+    end
+
     def to_sym
       Card::Format.format_sym self
     end

data/lib/card/format/content.rb

@@ -11,7 +11,8 @@ class Card
       # for all nests. After executing the given block the original nests are put back in.
       # Placeholders are numbers in double curly brackets like {{2}}.
       def safe_process_content override_content=nil, content_opts=nil, &block
-        content_obj = content_object override_content, chunk_list: :references
+        content_obj =
+          content_object override_content, chunk_list: :references_keep_escaping
         result = content_obj.without_references(&block)
         process_content result, content_opts
       end

data/lib/card/format/error.rb

@@ -3,9 +3,7 @@ class Card
     module Error
       def ok? task
         task = :create if task == :update && card.new_card?
-        @ok ||= {}
-        @ok[task] = card.ok? task if @ok[task].nil?
-        @ok[task]
+        card.ok? task
       end
 
       def anyone_can? task
@@ -53,15 +51,20 @@ class Card
       end
 
       def loud_error e, view
+        log_error e if focal? && voo.root?
         card.errors.add "#{view} view", rendering_error(e, view) if card.errors.empty?
         raise e
       end
 
       def quiet_error e, view
         # TODO: unify with Card::Error#report
+        log_error e
+        rendering_error e, view
+      end
+
+      def log_error e
         Rails.logger.info e.message
         Rails.logger.debug e.backtrace.join("\n")
-        rendering_error e, view
       end
 
       def rendering_error exception, view