card 1.99.1 → 1.99.2

data/mod/carrierwave/set/abstract/attachment.rb

@@ -1,5 +1,3 @@
-require "carrier_wave/cardmount"
-
 attr_writer :empty_ok
 
 def self.included host_class

data/mod/carrierwave/set/all/file_utils.rb

@@ -1,6 +1,6 @@
 module ClassMethods
   def update_all_storage_locations
-    Card.search(type_id: ["in", FileID, ImageID])
+    Card.search(type_id: ["in", Card::FileID, Card::ImageID])
         .each(&:update_storage_location!)
   end
 
@@ -34,4 +34,8 @@ module ClassMethods
         "AND card_actions.draft = true"
     )
   end
+
+  def count_cards_with_attachment
+    Card.search type_id: ["in", Card::FileID, Card::ImageID], return: :count
+  end
 end

data/mod/carrierwave/set/self/admin.rb

@@ -4,7 +4,7 @@ add_to_basket(
   execute_policy: -> { Card.update_all_storage_locations },
   stats: {
     title: "cards with attachment",
-    count: -> { Card.search(type_id: ["in", FileID, ImageID], return: :count) }
+    count: -> { Card.count_cards_with_attachment }
     # link_text: "update storage locations",
     # task: "update_file_storage_locations"
   }

data/mod/core/chunk/link.rb

@@ -1,113 +1,121 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency File.expand_path("../reference", __FILE__)
-
-module Card::Content::Chunk
-  class Link < Reference
-    CODE = "L".freeze # L for "Link"
-    attr_reader :link_text
-    # Groups: $1, [$2]: [[$1]] or [[$1|$2]] or $3, $4: [$3][$4]
-    Card::Content::Chunk.register_class self,
-                                        prefix_re: '\\[\\[',
-                                        full_re:   /\A\[\[([^\]]+)\]\]/,
-                                        idx_char:  "["
-    def reference_code
-      CODE
-    end
+# require File.expand_path("../reference", __FILE__)
+load File.expand_path("../reference.rb", __FILE__)
 
-    def interpret match, _content
-      target, @link_text =
-        if (raw_syntax = match[1])
-          if (i = divider_index(raw_syntax))  # [[A | B]]
-            [raw_syntax[0..(i - 1)], raw_syntax[(i + 1)..-1]]
-          else                                # [[ A ]]
-            [raw_syntax, nil]
-          end
+class Card
+  class Content
+    module Chunk
+      # extend ActiveSupport::Autoload
+      # autoload :Reference , "reference"
+
+      class Link < Card::Content::Chunk::Reference
+        CODE = "L".freeze # L for "Link"
+        attr_reader :link_text
+        # Groups: $1, [$2]: [[$1]] or [[$1|$2]] or $3, $4: [$3][$4]
+        Card::Content::Chunk.register_class self,
+                                            prefix_re: '\\[\\[',
+                                            full_re:   /\A\[\[([^\]]+)\]\]/,
+                                            idx_char:  "["
+        def reference_code
+          CODE
         end
 
-      @link_text = objectify @link_text
-      if target.match? %r{^(/|https?:|mailto:)}
-        @explicit_link = objectify target
-      else
-        @name = target
-      end
-    end
+        def interpret match, _content
+          target, @link_text =
+            if (raw_syntax = match[1])
+              if (i = divider_index(raw_syntax))  # [[A | B]]
+                [raw_syntax[0..(i - 1)], raw_syntax[(i + 1)..-1]]
+              else                                # [[ A ]]
+                [raw_syntax, nil]
+              end
+            end
 
-    def divider_index string
-      # there's probably a better way to do the following.
-      # point is to find the first pipe that's not inside an nest
-      return unless string.index "|"
-      string_copy = string.dup
-      string.scan(/\{\{[^\}]*\}\}/) do |incl|
-        string_copy.gsub! incl, ("x" * incl.length)
-      end
-      string_copy.index "|"
-    end
+          @link_text = objectify @link_text
+          if target.match? %r{^(/|https?:|mailto:)}
+            @explicit_link = objectify target
+          else
+            @name = target
+          end
+        end
 
-    # view options
-    def options
-      link_text ? { title: link_text } : {}
-    end
+        def divider_index string
+          # there's probably a better way to do the following.
+          # point is to find the first pipe that's not inside an nest
+          return unless string.index "|"
+          string_copy = string.dup
+          string.scan(/\{\{[^\}]*\}\}/) do |incl|
+            string_copy.gsub! incl, ("x" * incl.length)
+          end
+          string_copy.index "|"
+        end
 
-    def objectify raw
-      return unless raw
-      raw.strip!
-      if raw =~ /(^|[^\\])\{\{/
-        Card::Content.new raw, format
-      else
-        raw
-      end
-    end
+        # view options
+        def options
+          link_text ? { title: link_text } : {}
+        end
+
+        def objectify raw
+          return unless raw
+          raw.strip!
+          if raw =~ /(^|[^\\])\{\{/
+            Card::Content.new raw, format
+          else
+            raw
+          end
+        end
 
-    def render_link view: :link, explicit_link_opts: {}
-      @link_text = render_obj @link_text
+        def render_link view: :link, explicit_link_opts: {}
+          @link_text = render_obj @link_text
 
-      if @explicit_link
-        @explicit_link = render_obj @explicit_link
-        format.link_to_resource @explicit_link, @link_text, explicit_link_opts
-      elsif @name
-        format.with_nest_mode :normal do
-          format.nest referee_name, options.merge(view: view)
+          if @explicit_link
+            @explicit_link = render_obj @explicit_link
+            format.link_to_resource @explicit_link, @link_text, explicit_link_opts
+          elsif @name
+            format.with_nest_mode :normal do
+              format.nest referee_name, options.merge(view: view)
+            end
+          end
         end
-      end
-    end
 
-    def link_target
-      if @explicit_link
-        render_obj @explicit_link
-      elsif @name
-        referee_name
-      end
-    end
+        def link_target
+          if @explicit_link
+            render_obj @explicit_link
+          elsif @name
+            referee_name
+          end
+        end
 
-    def process_chunk
-      @process_chunk ||= render_link
-    end
+        def process_chunk
+          @process_chunk ||= render_link
+        end
 
-    def inspect
-      "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}]" \
+        def inspect
+          "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}]" \
       "p[#{@process_chunk}] txt:#{@text}>"
-    end
+        end
 
-    def replace_reference old_name, new_name
-      replace_name_reference old_name, new_name
-      replace_link_text old_name, new_name
-      @text =
-        @link_text.nil? ? "[[#{referee_name}]]" : "[[#{referee_name}|#{@link_text}]]"
-    end
+        def replace_reference old_name, new_name
+          replace_name_reference old_name, new_name
+          replace_link_text old_name, new_name
+          @text =
+            @link_text.nil? ? "[[#{referee_name}]]" : "[[#{referee_name}|#{@link_text}]]"
+        end
 
-    def replace_link_text old_name, new_name
-      if @link_text.is_a?(Card::Content)
-        @link_text.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-          chunk.replace_reference old_name, new_name
+        def replace_link_text old_name, new_name
+          if @link_text.is_a?(Card::Content)
+            @link_text.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
+              chunk.replace_reference old_name, new_name
+            end
+          elsif @link_text.present?
+            @link_text = old_name.to_name.sub_in(@link_text, with: new_name)
+          end
         end
-      elsif @link_text.present?
-        @link_text = old_name.to_name.sub_in(@link_text, with: new_name)
-      end
-    end
 
-    def explicit_link?
-      @explicit_link
+        def explicit_link?
+          @explicit_link
+        end
+      end
     end
   end
 end

data/mod/core/chunk/nest.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency File.expand_path("../reference", __FILE__)
+# require File.expand_path("../reference", __FILE__)
 
 class Card
   class Content
@@ -11,7 +11,7 @@ class Card
         DEFAULT_OPTION = :view # a value without a key is interpreted as view
 
         Chunk.register_class(self, prefix_re: '\\{\\{',
-                                   full_re:    /\A\{\{([^\}]*)\}\}/,
+                                   full_re:    /\A\{\{([^\{\}]*)\}\}/,
                                    idx_char:  "{")
 
         def interpret match, _content

data/mod/core/chunk/query_reference.rb

@@ -1,90 +1,95 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency File.expand_path("../reference", __FILE__)
+class Card
+  class Content
+    module Chunk
+      # This should find +Alfred+ in expressions like
+      # 1) {"name":"Alfred"}
+      # 2a) {"name":["in","Alfred"]}
+      # 3a) {"plus_right":["Alfred"]}
+      # but not in
+      # 2b) "content":"foo", "Alfred":"bar"
+      # 3b) {"name":["Alfred", "Toni"]}      ("Alfred" is an operator here)
+      # It's not possible to distinguish between 2a) and 2b) or 3a) and 3b) with a
+      # simple regex, hence we use a too general regex and check for query keywords
+      # after the match, which of course means that we don't find references with
+      # query keywords as name
 
-module Card::Content::Chunk
-  # This should find +Alfred+ in expressions like
-  # 1) {"name":"Alfred"}
-  # 2a) {"name":["in","Alfred"]}
-  # 3a) {"plus_right":["Alfred"]}
-  # but not in
-  # 2b) "content":"foo", "Alfred":"bar"
-  # 3b) {"name":["Alfred", "Toni"]}      ("Alfred" is an operator here)
-  # It's not possible to distinguish between 2a) and 2b) or 3a) and 3b) with a
-  # simple regex, hence we use a too general regex and check for query keywords
-  # after the match, which of course means that we don't find references with
-  # query keywords as name
+      require File.expand_path("reference", __dir__)
+      class QueryReference < Reference
+        QUERY_KEYWORDS = ::Set.new(
+          (
+            ::Card::Query::MODIFIERS.keys +
+            ::Card::Query::OPERATORS.keys +
+            ::Card::Query::ATTRIBUTES.keys +
+            ::Card::Query::CONJUNCTIONS.keys +
+            %w[desc asc count]
+          ).map(&:to_s)
+        )
 
-  class QueryReference < Reference
-    QUERY_KEYWORDS = ::Set.new(
-      (
-        Card::Query::MODIFIERS.keys +
-        Card::Query::OPERATORS.keys +
-        Card::Query::ATTRIBUTES.keys +
-        Card::Query::CONJUNCTIONS.keys +
-        %w[desc asc count]
-      ).map(&:to_s)
-    )
+        Card::Content::Chunk.register_class(
+          self, prefix_re: '(?<=[:,\\[])\\s*"',
+                # we check for colon, comma or square bracket before a quote
+                # we have to use a lookbehind, otherwise
+                # if the colon matches it would be
+                # identified mistakenly as an URI chunk
+                full_re: /\A\s*"([^"]+)"/,
+                idx_char: '"'
+        )
 
-    Card::Content::Chunk.register_class(
-      self, prefix_re: '(?<=[:,\\[])\\s*"',
-            # we check for colon, comma or square bracket before a quote
-            # we have to use a lookbehind, otherwise
-            # if the colon matches it would be
-            # identified mistakenly as an URI chunk
-            full_re:   /\A\s*"([^"]+)"/,
-            idx_char:  '"'
-    )
+        # OPTIMIZE: instead of comma or square bracket check for operator followed
+        # by comma or "plus_right"|"plus_left"|"plus" followed by square bracket
+        # something like
+        # prefix_patterns = [
+        #  "\"\\s*(?:#{Card::Query::OPERATORS.keys.join('|')})\"\\s*,",
+        #  "\"\\s*(?:#{Card::Query::PLUS_ATTRIBUTES}.keys
+        #    .join('|')})\\s*:\\s*\\[\\s*",
+        #  "\"\\s*(?:#{(QUERY_KEYWORDS - Card::Query::PLUS_ATTRIBUTES)
+        #    .join('|')})\"\\s*:",
+        # ]
+        # prefix_re: '(?<=#{prefix_patterns.join('|')})\\s*"'
+        # But: What do we do with the "in" operator? After the first value there is
+        # no prefix which we can use to detect the following values as
+        # QueryReference chunks
 
-    # OPTIMIZE: instead of comma or square bracket check for operator followed
-    # by comma or "plus_right"|"plus_left"|"plus" followed by square bracket
-    # something like
-    # prefix_patterns = [
-    #  "\"\\s*(?:#{Card::Query::OPERATORS.keys.join('|')})\"\\s*,",
-    #  "\"\\s*(?:#{Card::Query::PLUS_ATTRIBUTES}.keys
-    #    .join('|')})\\s*:\\s*\\[\\s*",
-    #  "\"\\s*(?:#{(QUERY_KEYWORDS - Card::Query::PLUS_ATTRIBUTES)
-    #    .join('|')})\"\\s*:",
-    # ]
-    # prefix_re: '(?<=#{prefix_patterns.join('|')})\\s*"'
-    # But: What do we do with the "in" operator? After the first value there is
-    # no prefix which we can use to detect the following values as
-    # QueryReference chunks
+        class << self
+          def full_match content, prefix
+            # matches cardnames that are not keywords
+            # FIXME: would not match cardnames that are keywords
+            match, offset = super(content, prefix)
+            return if !match || keyword?(match[1])
 
-    class << self
-      def full_match content, prefix
-        # matches cardnames that are not keywords
-        # FIXME: would not match cardnames that are keywords
-        match, offset = super(content, prefix)
-        return if !match || keyword?(match[1])
-        [match, offset]
-      end
+            [match, offset]
+          end
 
-      def keyword? str
-        return unless str
-        QUERY_KEYWORDS.include?(str.tr(" ", "_").downcase)
-      end
-    end
+          def keyword? str
+            return unless str
 
-    def interpret match, _content
-      @name = match[1]
-    end
+            QUERY_KEYWORDS.include?(str.tr(" ", "_").downcase)
+          end
+        end
 
-    def process_chunk
-      @process_chunk ||= @text
-    end
+        def interpret match, _content
+          @name = match[1]
+        end
 
-    def inspect
-      "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
-    end
+        def process_chunk
+          @process_chunk ||= @text
+        end
 
-    def replace_reference old_name, new_name
-      replace_name_reference old_name, new_name
-      @text = "\"#{@name}\""
-    end
+        def inspect
+          "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
+        end
 
-    def reference_code
-      "Q" # for "Query"
+        def replace_reference old_name, new_name
+          replace_name_reference old_name, new_name
+          @text = "\"#{@name}\""
+        end
+
+        def reference_code
+          "Q" # for "Query"
+        end
+      end
     end
   end
 end

data/mod/core/chunk/view_stub.rb

@@ -16,10 +16,19 @@ class Card
         end
 
         def interpret match, _content
-          @stub_hash = JSON.parse(match[1]).symbolize_keys
+          @stub_hash = initial_stub_hash match[1]
           interpret_hash_values
         end
 
+        def initial_stub_hash string
+          JSON.parse(string).symbolize_keys
+          # MessagePack.unpack(hex_to_bin(string)).symbolize_keys
+        end
+
+        def hex_to_bin string
+          string.scan(/../).map { |x| x.hex.chr }.join
+        end
+
         def interpret_hash_values
           @stub_hash.keys.each do |key|
             send "interpret_#{key}"