card 1.99.4 → 1.99.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04d3826e0397bc85a47f38887e9237206850f9cfca9bf0035d926b515c593556
-  data.tar.gz: 8d573ce53bc6f230965f46c7904c551eb93585c4dc7d7929c6cc78c42d706e37
+  metadata.gz: '0438dd31f0c6101dffdd517571880742e6ab883b1d571f83fed3659dbd6cd693'
+  data.tar.gz: de993267208ecc3c0fd5b10d8774c6f2b34bc2aa5c30816fcdd05f5fb6beb268
 SHA512:
-  metadata.gz: 40eab4353ed2bf29dfb6f7d451900c426250c5f1bf7dbe1242b9477afe40087065f3d04ed8c55975826d1ca681192d026d3122743abc9edbbf88514ccd762d42
-  data.tar.gz: 34b2ede0e2924c71c6b91adbdeeff9695ec42ff03544773c121c902300dc341cc7ea624d266c9d94c496bf6561af03f55bd6b24ef000e889b00813313d92b03e
+  metadata.gz: a4b2ed7e91ff665d2972b557851bf1402d2e0b16e21d709dffbe4b572ed21dca55939e9db76752252f67fda23e213310edfbd1b575704b3a980bb15850189725
+  data.tar.gz: 48a01c10b26897dc7e4062a0940d18ed10bd9b37ff4cea488d0c54e774e48bb5694c5deac08ee25a4a047dc0b0137a2a1556e9f6059903160122aa61c0f6480b

data/VERSION

@@ -1 +1 @@
-0.9.4
+0.9.5

data/lib/card/content.rb

@@ -132,7 +132,7 @@ class Card
 
     def unstash_chunks content, stashed_chunks
       Chunk::Nest.gsub content do |nest_content|
-        stashed_chunks[nest_content.to_i]
+        number?(nest_content) ? stashed_chunks[nest_content.to_i] : "{{#{nest_content}}}"
       end
     end
 
@@ -143,5 +143,11 @@ class Card
         format_or_card
       end
     end
+
+    def number? str
+      true if Float(str)
+    rescue StandardError
+      false
+    end
   end
 end

data/lib/card/content/chunk.rb

@@ -89,6 +89,7 @@ class Card
       register_list :nest_only, [:Nest]
       register_list :query, [:QueryReference]
       register_list :stub, [:ViewStub]
+      register_list :references_keep_escaping,  %i[KeepEscapedLiteral Nest Link]
     end
   end
   Card::Mod::Loader.load_chunks

data/lib/card/format.rb

@@ -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/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],

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/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

data/lib/card/view/cache.rb

@@ -214,8 +214,8 @@ class Card
       # Uses the primary cache API.
       def cache_fetch
         caching do
+          ensure_cache_key
           self.class.cache.fetch cache_key do
-            register_cache_key
             yield
           end
         end
@@ -240,8 +240,8 @@ class Card
       end
 
       # Registers the cached view for later clearing in the event of related card changes
-      def register_cache_key
-        card.register_view_cache_key cache_key
+      def ensure_cache_key
+        card.ensure_view_cache_key cache_key
       end
 
       def options_for_cache_key

data/lib/card/view/cache/cache_action.rb

@@ -112,11 +112,8 @@ class Card
         # altered view requests and altered cards are not cacheable
         # @return [True/False]
         def clean_enough_to_cache?
-          requested_view == ok_view && !card.unknown? && !card.db_content_changed?
-          # unknown views may be safe if we add type_id to the cache key for unknown
-          # (or all new?) cards.
-          #
-          #
+          #  requested_view == ok_view && !card.unknown? && !card.db_content_changed?
+          requested_view == ok_view && !card.db_content_changed?
         end
       end
     end

data/mod/basic_formats/set/all/all_csv.rb

@@ -35,7 +35,7 @@ format :csv  do
   end
 
   def name_with_fields_row
-    nested_fields.each_with_object([card.name]) do |(field_name, _options), row|
+    nested_field_names.each_with_object([card.name]) do |field_name, row|
       row << nest(field_name)
     end
   end
@@ -53,11 +53,7 @@ format :csv  do
   end
 
   def columns
-    columns = []
-    csv_structure_card.format.each_nested_field do |chunk|
-      columns << chunk.referee_name.tag
-    end
-    columns
+    csv_structure_card.format.nested_field_names.map(&:tag)
   end
 
   def csv_structure_card

data/mod/basic_formats/set/all/json.rb

@@ -1,7 +1,7 @@
 format :json do
   # because card.item_cards returns "[[#{self}]]"
   def item_cards
-    uniq_nested_cards
+    nested_cards
   end
 
   def default_nest_view

data/mod/core/chunk/{literal.rb → escaped_literal.rb}

@@ -19,7 +19,7 @@ class Card
         end
 
         def interpret match, _content
-          @process_chunk = match[0].sub(/^\\(.)/, '<span>\\1</span>')
+          @process_chunk = match[0].sub(/^\\(.)/, format.escape_literal('\1'))
         end
       end
     end

data/mod/core/chunk/keep_escaped_literal.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  class Content
+    module Chunk
+      # These are basic chunks that have a pattern and can be protected.
+      # This chunk is used for markdown processing to ensure that
+      # the escaping survives the markdown rendering.
+      class KeepEscapedLiteral < Abstract
+        FULL_RE = { "[" => /\A\\\[\[[^\]]*\]\]/,
+                    "{" => /\A\\\{\{[^\}]*\}\}/ }.freeze
+        Card::Content::Chunk.register_class self,
+                                            prefix_re: '\\\\(?:\\[\\[|\\{\\{)',
+                                            idx_char:  '\\'
+
+        def self.full_re prefix
+          FULL_RE[prefix[1, 1]]
+        end
+
+        def interpret match, _content
+          @process_chunk = match[0].sub(/^\\(.)/, '\\\\\\\\\1')
+        end
+      end
+    end
+  end
+end

data/mod/core/format/html_format.rb

@@ -28,6 +28,10 @@ class Card
         :bar
       end
 
+      def escape_literal literal
+        "<span>#{literal}</span>"
+      end
+
       def mime_type
         "text/html"
       end

data/mod/core/set/all/cache.rb

@@ -61,29 +61,24 @@ def cache_class_from_type cache_type
   cache_type ? Card.cache.send(cache_type) : Card.cache
 end
 
-def register_view_cache_key cache_key
-  view_cache_keys cache_key
-  hard_write_view_cache_keys
+def view_cache_keys
+  @view_cache_keys ||= hard_read_view_cache_keys || []
 end
 
-def view_cache_keys new_key=nil
-  @view_cache_keys ||= []
-  @view_cache_keys << new_key if new_key
-  append_missing_view_cache_keys
-  @view_cache_keys.uniq!
-  @view_cache_keys
+def ensure_view_cache_key cache_key
+  return if view_cache_keys.include? cache_key
+
+  @view_cache_keys << cache_key
+  hard_write_view_cache_keys
 end
 
-def append_missing_view_cache_keys
-  return unless Card.cache.hard
-  @view_cache_keys +=
-      (Card.cache.hard.read_attribute(key, :view_cache_keys) || [])
+def hard_read_view_cache_keys
+  Card.cache.hard&.read_attribute key, :view_cache_keys
 end
 
 def hard_write_view_cache_keys
   # puts "WRITE VIEW CACHE KEYS (#{name}): #{view_cache_keys}"
-  return unless Card.cache.hard
-  Card.cache.hard.write_attribute key, :view_cache_keys, view_cache_keys
+  Card.cache.hard&.write_attribute key, :view_cache_keys, view_cache_keys
 end
 
 def expire_views
@@ -92,7 +87,8 @@ def expire_views
   Array.wrap(view_cache_keys).each do |view_cache_key|
     Card::View.cache.delete view_cache_key
   end
-  @view_cache_keys = nil
+  @view_cache_keys = []
+  hard_write_view_cache_keys
 end
 
 def expire_names cache

data/mod/core/set/all/chunk.rb

@@ -28,120 +28,115 @@ def each_item_name_with_options content=nil
 end
 
 format do
-  def nested_fields content=nil
-    result = []
-    each_nested_card(content, true) do |chunk|
-      result << [chunk.referee_name, chunk.options]
-    end
-    result
-  end
-
-  def nested_field_cards content=nil
-    nested_fields(content).map do |name, _options|
-      Card.fetch name
-    end
+  def nest_chunks content=nil
+    content ||= _render_raw
+    card.nest_chunks content
   end
 
-  def nested_cards_for_edit fields_only=false
-    return normalized_edit_fields if edit_fields.present?
-    result = []
-    each_nested_card nil, fields_only do |chunk|
-      result << [chunk.options[:nest_name], chunk.options]
-    end
-    result
+  def nested_cards content=nil
+    nest_chunks(content).map(&:referee_card).uniq
   end
 
   def edit_fields
     voo.edit_structure || []
   end
 
-  def normalized_edit_fields
-    edit_fields.map do |cardish, options|
-      field_mark = normalized_edit_field_mark cardish, options
-      options = normalized_edit_field_options options, Card::Name[field_mark]
-      [field_mark, options]
-    end
+  def nested_field_names content=nil
+    nest_chunks(content).map(&:referee_name).select { |n| field_name? n }
   end
 
-  def normalized_edit_field_options options, cardname
-    options ||= cardname
-    options.is_a?(String) ? { title: options } : options
+  def nested_field_cards content=nil
+    nested_cards(content).select { |c| field_name? c.name }
   end
 
-  def normalized_edit_field_mark cardish, options
-    return cardish if cardish.is_a?(Card) ||
-                      (options.is_a?(Hash) && options.delete(:absolute))
-    card.name.field cardish
+  def field_name? name
+    name.field_of? card.name
   end
 
-  def process_field chunk, processed
-    return unless process_unique_field? chunk, processed
-    yield chunk if block_given?
+  # @return [Array] of Arrays.  each is [nest_name, nest_options_hash]
+  def edit_field_configs fields_only=false
+    if edit_fields.present?
+      explicit_edit_fields_config # explicitly configured in voo or code
+    else
+      implicit_edit_fields_config fields_only # inferred from nests
+    end
   end
 
-  def each_nested_field content=nil, &block
-    each_nested_card content, true, &block
+  def implicit_edit_fields_config fields_only
+    result = []
+    each_nested_chunk(fields: fields_only) do |chunk|
+      result << [chunk.options[:nest_name], chunk.options]
+    end
+    result
   end
 
-  def each_nested_card content=nil, fields_only=false, &block
-    processed = process_tally
-    nest_chunks(content).each do |chunk|
-      next if fields_only && !field_chunk?(chunk)
-      process_nested_chunk chunk, processed, &block
-    end
+  def each_nested_field_chunk &block
+    each_nested_chunk fields: true, &block
   end
 
-  def uniq_nested_cards content: nil
-    with_unique_chunks do
-      nest_chunks(content).map do |chunk|
-        chunk.referee_card if unique_chunk? chunk
-      end
-    end
+  def each_nested_chunk content: nil, fields: false, uniq: true, virtual: true, &block
+    return unless block_given?
+    chunks = prepare_nested_chunks content, fields, uniq
+    process_nested_chunks chunks, virtual, &block
   end
 
-  def nest_chunks content=nil
-    content ||= _render_raw
-    card.nest_chunks content
+  def uniq_chunks chunks
+    processed = ::Set.new [card.key]
+    chunks.select do |chunk|
+      key = chunk.referee_name.key
+      ok = !processed.include?(key)
+      processed << key
+      ok
+    end
   end
 
-  def process_tally
-    ::Set.new [card.key]
+  def field_chunks chunks
+    chunks.select { |chunk| field_name?(chunk.referee_name) }
   end
 
-  def field_chunk? chunk
-    chunk.referee_name.to_name.field_of? card.name
+  private
+
+  def prepare_nested_chunks content, fields, uniq
+    chunks = nest_chunks content
+    chunks = field_chunks chunks if fields
+    chunks = uniq_chunks chunks if uniq
+    chunks
   end
 
-  def unique_chunk? chunk
-    key = chunk.referee_name.key
-    return false if @processed.include? key
-    @processed << key
-    true
+  def process_nested_chunks chunks, virtual, &block
+    chunks.each do |chunk|
+      process_nested_chunk chunk, virtual, &block
+    end
   end
 
-  def with_unique_chunks
-    @processed = ::Set.new [card.key]
-    yield
+  def process_nested_chunk chunk, virtual, &block
+    if chunk.referee_card&.virtual?
+      process_nested_virtual_chunk chunk, &block unless virtual
+    else
+      yield chunk
+    end
   end
 
-  def process_nested_chunk chunk, processed, &block
-    virtual = chunk.referee_card&.virtual?
-    # TODO: handle structures that are non-virtual
-    method = virtual ? :process_virtual_field : :process_field
-    send method, chunk, processed, &block
+  def process_virtual_chunk chunk
+    subformat(chunk.referee_card).each_nested_field_chunk { |sub_chunk| yield sub_chunk }
   end
 
-  def process_virtual_field chunk, processed, &block
-    return unless process_unique_field? chunk, processed
-    subformat(chunk.referee_card).each_nested_field do |sub_chunk|
-      process_field sub_chunk, processed, &block
+  def explicit_edit_fields_config
+    edit_fields.map do |cardish, options|
+      field_mark = normalized_edit_field_mark cardish, options
+      options = normalized_edit_field_options options, Card::Name[field_mark]
+      [field_mark, options]
     end
   end
 
-  def process_unique_field? chunk, processed
-    key = chunk.referee_name.key
-    return false if processed.include? key
-    processed << key
-    true
+  def normalized_edit_field_options options, cardname
+    options ||= cardname
+    options.is_a?(String) ? { title: options } : options
+  end
+
+  def normalized_edit_field_mark cardish, options
+    return cardish if cardish.is_a?(Card) ||
+                      (options.is_a?(Hash) && options.delete(:absolute))
+    card.name.field cardish
   end
 end