card 1.99.6 → 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,33 +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
-        return dir if dir.main
-
-        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

@@ -37,6 +37,14 @@ class Card
         self[:params] ||= {}
       end
 
+      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

data/lib/card/env/location.rb

@@ -25,7 +25,8 @@ class Card
       end
 
       def cardname_from_url url
-        m = url.match cardname_from_url_regexp
+        return unless (cardname = cardname_from_url_regexp)
+        m = url.match cardname
         m ? Card::Name[m[:mark]] : nil
       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.

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

data/lib/card/format/nesting.rb

@@ -7,7 +7,7 @@ class Card
       include Mode
 
       # @param cardish card mark
-      # @param view_opts [Hash] {Card/View/Options view options}, passed on to render.
+      # @param view_opts [Hash] {Card::View::Options view options}, passed on to render.
       # @param format_opts [Hash] opts will be passed on to subformat
       def nest cardish, view_opts={}, format_opts={}
         return "" if nest_invisible?

data/lib/card/lexicon.rb

@@ -0,0 +1,90 @@
+class Card
+  # Translates names to ids and vice versa via a cached "lex" representation:
+  # name for simple cards, [left_id, right_id] for compound cards.
+  #
+  # Note, unlike Card::Fetch, Card::Lexicon:
+  #   1. does NOT distinguish between trashed and untrashed cards.
+  #   2. does NOT respect local name changes
+  module Lexicon
+    class << self
+      # param id [Integer]
+      # @return [String]
+      def name id
+        return unless id.present?
+
+        name = (lex = id_to_lex id) && lex_to_name(lex)
+        (name || "").to_name
+      end
+
+      # param name [String]
+      # @return [Integer]
+      def id name
+        return unless name.present?
+
+        (lex = name_to_lex name.to_name) && lex_to_id(lex)
+      end
+
+      def cache
+        Card::Cache[Lexicon]
+      end
+
+      def add card
+        lex = card.lex
+        cache.write card.id.to_s, lex
+        cache.write cache_key(lex), card.id
+      end
+
+      def update card
+        add card
+        cache.delete cache_key(card.old_lex)
+      end
+
+      # def delete card
+      #   cache.delete card.id.to_s
+      #   cache.delete cache_key(card.old_lex)
+      # end
+
+      def lex_to_name lex
+        return lex unless lex&.is_a? Array
+        lex.map { |side_id| name side_id or return }.join(Card::Name.joint).to_name
+      end
+
+      private
+
+      def id_to_lex id
+        cache.fetch id.to_s do
+          result = Card.where(id: id).pluck(:name, :left_id, :right_id).first
+          return unless result
+
+          result[0] || [result[1], result[2]]
+        end
+      end
+
+      def name_to_lex name
+        if name.simple?
+          name
+        elsif (left_id = id name.left_name) && (right_id = id name.right_name)
+          [left_id, right_id]
+        end
+      end
+
+      def lex_to_id lex
+        cache.fetch cache_key(lex) do
+          Card.where(lex_query(lex)).pluck(:id).first
+        end
+      end
+
+      def lex_query lex
+        if lex.is_a?(Array)
+          { left_id: lex.first, right_id: lex.last }
+        else
+          { key: lex.to_name.key }
+        end
+      end
+
+      def cache_key lex
+        "L-" + (lex.is_a?(Array) ? lex.join("-") : lex.to_name.key)
+      end
+    end
+  end
+end

data/lib/card/mod.rb

@@ -51,7 +51,7 @@ class Card
   #   - {Card::Set} provides an overview of how set modules work
   #   - {Card::Set::Format} explains the basics of the format API
   #   - {Card::Set::Format::AbstractFormat} explains the basics of the view definition API
-  #   - {Card::Set::Event} explains the basics of the event API
+  #   - {Card::Set::Event:Api} explains the basics of the event API
   #
   # ## Other Directories
   #

data/lib/card/mod/load_strategy/set_tmp_files.rb

@@ -22,7 +22,7 @@ class Card
 
         def load_tmp_files
           @mod_dirs.each_tmp(:set) do |set_tmp_dir|
-            Card::Set::Pattern.in_load_order.each do |pattern|
+            Card::Set::Pattern.loadable_codes.each do |pattern|
               pattern_dir = "#{set_tmp_dir}/#{pattern}"
               Loader.load_dir "#{pattern_dir}/**" if Dir.exist? pattern_dir
             end

data/lib/card/mod/loader/set_loader.rb

@@ -55,7 +55,8 @@ class Card
             @content.gsub!(/^ *format +:?(\w+)? *do *$/) do
               format_name = $1.blank? ? nil : $1.to_sym
               "module #{module_name format_name}; " \
-              "parent.send :register_set_format, #{format_class format_name}, self; "\
+              "module_parent.send :register_set_format, "\
+              "#{format_class format_name}, self; "\
               "extend Card::Set::AbstractFormat"
             end
           end

data/lib/card/mod/module_template.rb

@@ -2,8 +2,8 @@ class Card
   module Mod
     # ModuleTemplate is an abstract class to build ruby modules out of
     # deckos dsl for sets and set patterns.
-    # {SetLoader::Template} and {SetPatternLoader::Template} inherit from it and
-    # adapt the template to their needs.
+    # {Loader::SetLoader::Template} and {Loader::SetPatternLoader::Template} inherit
+    # from it and adapt the template to their needs.
     class ModuleTemplate
       def initialize modules, content_path, strategy
         modules = Array.wrap modules

data/lib/card/name.rb

@@ -13,9 +13,6 @@ class Card
     include FieldsAndTraits
     include NameVariants
 
-    self.params  = Card::Env # yuck!
-    self.session = proc { Card::Auth.current.name } # also_yuck
-
     class << self
       def [] *cardish
         cardish = cardish.first if cardish.size <= 1
@@ -29,6 +26,14 @@ class Card
         end
       end
 
+      def session
+        Card::Auth.current.name # also_yuck
+      end
+
+      def params
+        Card::Env.params
+      end
+
       def new str, validated_parts=nil
         return compose str if str.is_a?(Array)
 

data/lib/card/query.rb

@@ -78,10 +78,9 @@ class Card
                 .each_with_object({}) { |v, h| h[v] = nil }
 
     OPERATORS =
-      %w[!= = =~ < > in ~].each_with_object({}) { |v, h| h[v] = v }.merge(
-        {
-          eq: "=", gt: ">", lt: "<", match: "~", ne: "!=", "not in": "not in"
-        }.stringify_keys
+      %w[!= = =~ < > in ~ is].each_with_object({}) { |v, h| h[v] = v }.merge(
+        { eq: "=", gt: ">", lt: "<", match: "~", ne: "!=",
+          "not in": "not in", "is not": "is not", "!": "is not" }.stringify_keys
       )
 
     DEFAULT_ORDER_DIRS = { update: "desc", relevance: "desc" }.freeze

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

@@ -9,82 +9,35 @@ class Card
       module MatchAttributes
         # match term anywhere in name or content
         def match val
-          val.gsub!(/[^#{Card::Name::OK4KEY_RE}]+/, " ")
-          return nil if val.strip.empty?
-
-          val.gsub!("*", '\\\\\\\\*')
-          val_list = val.split(/\s+/).map do |v|
-            name_or_content_match v
+          return unless val.present?
+          subconds = %i[name content].map do |field|
+            Value.new([:match, val], self).to_sql field
           end
-          add_condition and_join(val_list)
+          add_condition or_join(subconds)
         end
 
         # match names beginning with term
         def complete val
-          add_condition key_like("#{val.to_name.key}%", val =~ /\+/)
+          val = val.to_name
+          if val.junction?
+            interpret left: val.left
+            interpret right: { complete: val.right } if val.right.present?
+          else
+            add_condition "#{table_alias}.key LIKE '#{val.to_name.key}%'"
+          end
         end
 
         # match term anywhere in name
         # DEPRECATE - move handling to name: ["match", val]
         def name_match val
-          add_condition name_like(val)
+          interpret name: [:match, val]
         end
 
         private
 
-        def name_or_content_match val
-          cxn = connection
-          or_join([name_like(val), content_match(val, cxn)])
-        end
-
-        def name_like val
-          key_like "%#{val.to_name.key}%"
-        end
-
-        def content_match val, cxn
-          field_match "#{table_alias}.db_content", val, cxn
-        end
-
-        def field_match field, val, cxn
-          %(#{field} #{cxn.match quote(wrap_with_word_boundary_check(val, cxn))})
-        end
-
-        def wrap_with_word_boundary_check val, cxn
-          if mysql_8_0_4?(cxn)
-            "\\b#{val}\\b"
-          else
-            "[[:<:]]#{val}[[:>:]]"
-          end
-        end
-
-        # Since version 8.0.4 mysql uses a different syntax for word boundaries in
-        # regular expresions
-        def mysql_8_0_4? cxn
-          return false unless cxn.class.name.include? "Mysql2"
-
-          mysql_version =
-            cxn.select_rows("SHOW VARIABLES WHERE Variable_name = 'version'")[0][1]
-          Gem::Version.new(mysql_version) >= Gem::Version.new("8.0.4")
-        end
-
-        # TODO: move sql to SqlStatement
-        def key_like pattern, junction_ok=true
-          conds = ["#{table_alias}.key LIKE #{quote pattern}"]
-          conds << "#{table_alias}.right_id is null" unless junction_ok
-          # FIXME: -- this should really be more nuanced --
-          # it includes all descendants after one plus
-          conds.join " AND "
-        end
-
-        # TODO: use standard conjunction handling
-
         def or_join conditions
           "(#{Array(conditions).join ' OR '})"
         end
-
-        def and_join conditions
-          "(#{Array(conditions).join ' AND '})"
-        end
       end
     end
   end