card 1.99.2 → 1.100.0

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/loader/set_pattern_loader.rb

@@ -38,7 +38,11 @@ class Card
           end
 
           def preamble_bits
-            [module_comment, module_chain, "cattr_accessor :options", "class << self"]
+            [module_comment,
+             module_chain,
+             "extend Card::Set::Pattern::Helper",
+             "cattr_accessor :options",
+             "class << self"]
           end
 
           def postamble

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/model/save_helper.rb

@@ -70,10 +70,14 @@ class Card
       # The derived codename is all lower case with underscores; "*" and ":" are removed
       def ensure_code_card name_or_args, content_or_args=nil
         name, args = standardize_ensure_args name_or_args, content_or_args
-        args[:codename] = name.downcase.tr(" ", "_").tr(":*", "") unless args[:codename]
+        args[:codename] = codename_from_name(name) unless args[:codename]
         ensure_card_simplified name, args
       end
 
+      def codename_from_name name
+        name.downcase.tr(" ", "_").tr(":*", "")
+      end
+
       # create if card doesn't exist
       # updates existing card only if given attributes are different including
       # the name

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

@@ -62,8 +62,8 @@ class Card
                           refer_to referred_to_by
                           member_of member
 
-                          found_by not sort match name_match complete
-                          extension_type],
+                          found_by
+                          not sort match name_match complete],
 
       plus_relational: %i[plus left_plus right_plus],
       conjunction:     %i[and or all any],
@@ -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/abstract_query.rb

@@ -19,7 +19,7 @@ class Card
 
       attr_reader :statement, :mods, :conditions, :vars,
                   :subqueries, :superquery, :comment, :negate
-      attr_accessor :joins, :conditions_on_join, :table_seq
+      attr_accessor :joins, :conditions_on_join
 
       def initialize statement, _comment=nil
         @subqueries = []

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

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

@@ -18,8 +18,8 @@ class Card
         def clause_to_hash clause
           case clause
           when Hash              then clause
-          when String            then { key: clause.to_name.key }
           when Integer           then { id: clause }
+          when String            then { id: (Card::Lexicon.id(clause) || -2) }
           when Symbol            then { id: Card::Codename.id(clause) }
           else raise Error::BadQuery, "Invalid clause: #{clause.inspect}"
           end
@@ -27,9 +27,9 @@ class Card
 
         def normalize_value val
           case val
-          when Integer, Float, Hash, Symbol then val
-          when String                       then normalize_string_value val
-          when Array                        then normalize_array_value val
+          when Integer, Float, Hash, Symbol, NilClass then val
+          when String                                 then normalize_string_value val
+          when Array                                  then normalize_array_value val
           else raise Error::BadQuery, "Invalid value type: #{val.class} (#{val.inspect})"
           end
         end

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

@@ -33,6 +33,7 @@ class Card
           when respond_to?(:"#{retrn}_result") then :"#{retrn}_result"
           when (retrn =~ /id$/)                then :id_result
           when (retrn =~ /_\w+/)               then :name_result
+          when (retrn == "key")                then :key_result
           else                                      :default_result
           end
         end
@@ -53,20 +54,26 @@ class Card
           record
         end
 
-        def name_result record, pattern
-          process_name record["name"], pattern
+        def key_result record, pattern=""
+          name_result(record, pattern).to_name.key
+        end
+
+        def name_result record, pattern=""
+          name = record["name"]&.to_name
+          name ||= Card::Lexicon.lex_to_name [record["left_id"], record["right_id"]]
+          process_name name, pattern
         end
 
         def card_result record, _field
           if alter_results?
-            Card.fetch alter_result(record["name"]), new: {}
+            Card.fetch name_result(record), new: {}
           else
             fetch_or_instantiate record
           end
         end
 
         def fetch_or_instantiate record
-          card = Card.retrieve_from_cache record["key"]
+          card = Card.retrieve_from_cache_by_id record["id"]
           unless card
             card = Card.instantiate record
             Card.write_to_cache card
@@ -76,11 +83,11 @@ class Card
         end
 
         def run_sql
-          # puts "\nstatement = #{@statement}"
-          ActiveRecord::Base.connection.select_all(sql)
+          # puts "\nSQL = #{sql}"
+          ActiveRecord::Base.connection.select_all sql
         end
 
-        def process_name name, pattern
+        def process_name name, pattern=""
           name = pattern.to_name.absolute(name) if pattern =~ /_\w+/
           return name unless alter_results?
 

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

@@ -47,7 +47,7 @@ class Card
 
         def sort_by_count val, item
           method_name = "sort_by_count_#{item}"
-          sort_by_count_not_implemented :count, item unless respond_to? method_name
+          sort_method_not_implemented :count, item unless respond_to? method_name
           send method_name, val
         end
 

data/lib/card/query/sql_statement.rb

@@ -11,10 +11,6 @@ class Card
     # hierarchy and do little more than run "to_sql" on its parts, and in so doing
     # construct a valid SQL statement.
     class SqlStatement
-      require "card/query/sql_statement/joins"
-      require "card/query/sql_statement/where"
-      require "card/query/sql_statement/order"
-
       include Joins
       include Where
       include Order
@@ -73,17 +69,20 @@ class Card
 
       def full_field table, field
         case field
-        when :raw      then "#{table}.*"
-        when :card     then "#{table}.*"
-        when :content  then "#{table}.db_content"
-        when :count
-          "coalesce(count( distinct #{table}.id),0) as count"
+        when :card, :raw then "#{table}.*"
+        when :content    then "#{table}.db_content"
+        when :name, :key then "#{table}.name, #{table}.left_id, #{table}.right_id"
+        when :count      then "coalesce(count( distinct #{table}.id),0) as count"
         else
-          if ATTRIBUTES[field.to_sym] == :basic
-            "#{table}.#{field}"
-          else
-            safe_sql field
-          end
+          standard_full_field table, field
+        end
+      end
+
+      def standard_full_field table, field
+        if ATTRIBUTES[field.to_sym] == :basic
+          "#{table}.#{field}"
+        else
+          safe_sql field
         end
       end