card-mod-content 0.11.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb52b2764cccee68e9de8d73edf69ae8be71529d81728b009fbf2f93bac63964
+  data.tar.gz: 576999f00236a239917c9671a301358987554468e9e6b1640616f3c5a6cd1134
+SHA512:
+  metadata.gz: d375445000c6b0de05d4f455f24b45dde8999bc38e1e5021342865e74aa8d8e02ad057460411fa79c52892d15bdc97c0897ed4fe59a8a5cb37ab5ab08b234575
+  data.tar.gz: b01ba00743f9392eee0ace1b6717fcbd5a2ca21c5b4b619a01ef51fd66ecb4e3c15628d6d90e90d0850cff22a8693ef4a2e3c516ae2c6b2c8f16c539cd82d813

data/lib/card/content/chunk/escaped_literal.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  class Content
+    module Chunk
+      # These are basic chunks that have a pattern and can be protected.
+      # They are used by rendering process to prevent wiki rendering
+      # occuring within literal areas such as <code> and <pre> blocks
+      # and within HTML tags.
+      class EscapedLiteral < 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(/^\\(.)/, format.escape_literal('\1'))
+        end
+      end
+    end
+  end
+end

data/lib/card/content/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/lib/card/content/chunk/link.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+
+# require File.expand_path("../reference", __FILE__)
+load File.expand_path("../reference.rb", __FILE__)
+
+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
+
+        def interpret match, _content
+          target, @link_text = target_and_link_text match[1]
+
+          @link_text = objectify @link_text
+          if target.match? %r{^(/|https?:|mailto:)}
+            @explicit_link = objectify target
+          else
+            @name = target
+          end
+        end
+
+        def target_and_link_text raw_syntax
+          return unless raw_syntax
+
+          if (i = divider_index raw_syntax)                    # [[A | B]]
+            [raw_syntax[0..(i - 1)], raw_syntax[(i + 1)..-1]]  # [A, B]
+          else                                                 # [[ A ]]
+            [raw_syntax, nil]                                  # [A, 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
+
+        # view options
+        def options
+          link_text ? { title: link_text } : {}
+        end
+
+        def objectify raw
+          return unless raw
+          raw.strip!
+          if raw.match?(/(^|[^\\])\{\{/)
+            Card::Content.new raw, format
+          else
+            raw
+          end
+        end
+
+        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)
+            end
+          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 inspect
+          "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}]" \
+      "p[#{@process_chunk}] txt:#{@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
+            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
+        end
+      end
+    end
+  end
+end

data/lib/card/content/chunk/nest.rb

@@ -0,0 +1,126 @@
+# -*- encoding : utf-8 -*-
+
+# require File.expand_path("../reference", __FILE__)
+
+class Card
+  class Content
+    module Chunk
+      # Handler for nest chunks: {{example}}
+      class Nest < Reference
+        attr_reader :options
+        DEFAULT_OPTION = :view # a value without a key is interpreted as view
+
+        Chunk.register_class(self, prefix_re: '\\{\\{',
+                                   full_re:    /\A\{\{([^\{\}]*)\}\}/,
+                                   idx_char:  "{")
+
+        def interpret match, _content
+          in_brackets = strip_tags match[1]
+          name, @opt_lists = in_brackets.split "|", 2
+          name = name.to_s.strip
+          if name.match?(/^\#/)
+            @process_chunk = name.match?(/^\#\#/) ? "" : visible_comment(in_brackets)
+          else
+            @options = interpret_options.merge nest_name: name, nest_syntax: in_brackets
+            @name = name
+          end
+        end
+
+        def strip_tags string
+          # note: not using ActionView's strip_tags here
+          # because this needs to be super fast.
+          string.gsub(/\<[^\>]*\>/, "")
+        end
+
+        def visible_comment message
+          "<!-- #{CGI.escapeHTML message} -->"
+        end
+
+        def interpret_options
+          raw_options = @opt_lists.to_s.split("|").reverse
+          raw_options.inject(nil) do |prev_level, level_options|
+            interpret_piped_options level_options, prev_level
+          end || {}
+        end
+
+        def interpret_piped_options list_string, items
+          options_hash = items.nil? ? {} : { items: items }
+          option_string_to_hash list_string, options_hash
+          options_hash
+        end
+
+        def option_string_to_hash list_string, options_hash
+          each_option(list_string) do |key, value|
+            key = key.to_sym
+            if key == :item
+              options_hash[:items] ||= {}
+              options_hash[:items][:view] = value
+            elsif Card::View::Options.shark_keys.include? key
+              options_hash[key] = value
+              # else
+              # handle other keys
+            end
+          end
+        end
+
+        def inspect
+          "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
+        end
+
+        def process_chunk
+          return @process_chunk if @process_chunk
+
+          referee_name
+          @processed = format.content_nest(@options)
+          # this is not necessarily text, sometimes objects for json
+        end
+
+        def replace_reference old_name, new_name
+          replace_name_reference old_name, new_name
+          nest_body = [@name.to_s, @opt_lists].compact * "|"
+          @text = "{{#{nest_body}}}"
+        end
+
+        def explicit_view= view
+          return if @options[:view]
+          # could check to make sure it's not already the default...
+          if @text.match?(/\|/)
+            @text.sub! "|", "|#{view};"
+          else
+            @text.sub! "}}", "|#{view}}}"
+          end
+        end
+
+        def main?
+          nest_name == "_main"
+        end
+
+        def nest_name
+          options&.dig :nest_name
+        end
+
+        def self.gsub string
+          string.gsub(/\{\{([^\}]*)\}\}/) do |_match|
+            yield(Regexp.last_match[1])
+          end
+        end
+
+        def raw_options
+          @opt_lists
+        end
+
+        private
+
+        def each_option attr_string
+          return if attr_string.blank?
+          attr_string.strip.split(";").each do |pair|
+            # key is optional for view option
+            value, key = pair.split(":", 2).reverse
+            key ||= self.class::DEFAULT_OPTION.to_s
+            yield key.strip, value.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/content/chunk/query_reference.rb

@@ -0,0 +1,95 @@
+# -*- encoding : utf-8 -*-
+
+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
+
+      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)
+        )
+
+        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
+
+        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
+
+          def keyword? str
+            return unless str
+
+            QUERY_KEYWORDS.include?(str.tr(" ", "_").downcase)
+          end
+        end
+
+        def interpret match, _content
+          @name = match[1]
+        end
+
+        def process_chunk
+          @process_chunk ||= @text
+        end
+
+        def inspect
+          "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
+        end
+
+        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/lib/card/content/chunk/reference.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  class Content
+    module Chunk
+      class Reference < Abstract
+        attr_writer :referee_name
+        attr_accessor :name
+
+        def referee_name
+          return if name.nil?
+          @referee_name ||= referee_name_from_rendered(render_obj(name))
+          @referee_name = @referee_name.absolute(card.name).to_name
+        rescue Card::Error::NotFound
+          # do not break on missing id/codename references.
+        end
+
+        def referee_name_from_rendered rendered_name
+          ref_card = fetch_referee_card rendered_name
+          ref_card ? ref_card.name : rendered_name.to_name
+        end
+
+        def referee_card
+          @referee_card ||= referee_name && Card.fetch(referee_name)
+        end
+
+        def replace_name_reference old_name, new_name
+          @referee_card = nil
+          @referee_name = nil
+          if name.is_a? Card::Content
+            name.find_chunks(Chunk::Reference).each do |chunk|
+              chunk.replace_reference old_name, new_name
+            end
+          else
+            @name = name.to_name.swap old_name, new_name
+          end
+        end
+
+        def render_obj raw
+          if format && raw.is_a?(Card::Content)
+            format.process_content raw
+          else
+            raw
+          end
+        end
+
+        private
+
+        def fetch_referee_card rendered_name
+          case rendered_name # FIXME: this should be standard fetch option.
+          when /^\~(\d+)$/ # get by id
+            Card.fetch Regexp.last_match(1).to_i
+          when /^\:(\w+)$/ # get by codename
+            Card.fetch Regexp.last_match(1).to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/content/chunk/uri.rb

@@ -0,0 +1,145 @@
+# -*- encoding : utf-8 -*-
+
+require "uri"
+
+# This wiki chunk matches arbitrary URIs, using patterns from the Ruby URI
+# modules.
+# It parses out a variety of fields that could be used by formats to format
+# the links in various ways (shortening domain names, hiding email addresses)
+# It matches email addresses and host.com.au domains without schemes (http://)
+# but adds these on as required.
+#
+# The heuristic used to match a URI is designed to err on the side of caution.
+# That is, it is more likely to not autolink a URI than it is to accidently
+# autolink something that is not a URI. The reason behind this is it is easier
+# to force a URI link by prefixing 'http://' to it than it is to escape and
+# incorrectly marked up non-URI.
+#
+# I'm using a part of the [ISO 3166-1 Standard][iso3166] for country name
+# suffixes.
+# The generic names are from www.bnoack.com/data/countrycode2.html)
+#   [iso3166]: http://geotags.com/iso3166/
+module Card::Content::Chunk
+  class Uri < Abstract
+    SCHEMES = %w[irc http https ftp ssh git sftp file ldap ldaps mailto].freeze
+
+    REJECTED_PREFIX_RE = %w{! ": " ' ](}.map { |s| Regexp.escape s } * "|"
+
+    attr_reader :uri, :link_text
+    delegate :to, :scheme, :host, :port, :path, :query, :fragment, to: :uri
+
+    Card::Content::Chunk.register_class(
+      self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})(?:#{SCHEMES * '|'})\\:)",
+            full_re: /\A#{::URI.regexp(SCHEMES)}/,
+            idx_char: ":"
+    )
+
+    class << self
+      def full_match content, prefix
+        prepend_str = if prefix[-1, 1] != ":" && config[:prepend_str]
+                        config[:prepend_str]
+                      else
+                        ""
+                      end
+        content = prepend_str + content
+        match = super content, prefix
+        [match, prepend_str.length]
+      end
+
+      def context_ok? content, chunk_start
+        preceding_string = content[chunk_start - 2..chunk_start - 1]
+        preceding_string !~ /(?:#{REJECTED_PREFIX_RE})$/
+      end
+    end
+
+    def interpret match, _content
+      chunk = match[0]
+      last_char = chunk[-1, 1]
+      chunk.gsub!(/(?:&nbsp;)+/, "")
+
+      @trailing_punctuation =
+        if %w[, . ) ! ? :].member?(last_char)
+          @text.chop!
+          chunk.chop!
+          last_char
+        end
+      chunk.sub!(/\.$/, "")
+
+      @link_text = chunk
+      @uri = ::URI.parse(chunk)
+      @process_chunk = process_uri_chunk
+    rescue ::URI::Error => e
+      # warn "rescue parse #{chunk_class}:
+      # '#{m}' #{e.inspect} #{e.backtrace*"\n"}"
+      Rails.logger.warn "rescue parse #{self.class}: #{e.inspect}"
+    end
+
+    private
+
+    def process_text
+      @link_text
+    end
+
+    def process_uri_chunk
+      link = format.link_to_resource @link_text, process_text
+      "#{link}#{@trailing_punctuation}"
+    end
+  end
+
+  # FIXME: DRY, merge these two into one class
+  class EmailUri < Uri
+    PREPEND_STR = "mailto:".freeze
+    EMAIL = '[a-zA-Z\\d](?:[-a-zA-Z\\d.]*[a-zA-Z\\d])?\\@'.freeze
+
+    Card::Content::Chunk.register_class(
+      self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})#{EMAIL})\\b",
+            full_re: /\A#{::URI.regexp(SCHEMES)}/,
+            prepend_str: PREPEND_STR,
+            idx_char: "@"
+    )
+
+    # removes the prepended string from the unchanged match text
+    def process_text
+      @text = @text.sub(/^mailto:/, "")
+    end
+  end
+
+  class HostUri < Uri
+    GENERIC = "aero|biz|com|coop|edu|gov|info|int|mil|" \
+              "museum|name|net|org".freeze
+
+    COUNTRY = "ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|az|ba|bb|bd|be|" \
+              "bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cf|cd|cg|" \
+              "ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|de|dj|dk|dm|do|dz|" \
+              "ec|ee|eg|eh|er|es|et|fi|fj|fk|fm|fo|fr|fx|ga|gb|gd|ge|gf|gh|" \
+              "gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|" \
+              "il|in|io|iq|ir|is|it|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|" \
+              "kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|mg|mh|mk|ml|mm|" \
+              "mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|" \
+              "no|np|nr|nt|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|pt|pw|py|" \
+              "qa|re|ro|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|" \
+              "st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|tm|tn|to|tp|tr|tt|tv|tw|" \
+              "tz|ua|ug|uk|um|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|yu|" \
+              "za|zm|zr|zw|" \
+              "eu".freeze # made this separate, since it's not technically
+    # a country -efm
+    # These are needed otherwise HOST will match almost anything
+
+    TLDS = "(?:#{GENERIC}|#{COUNTRY})".freeze
+    # TLDS = "(?:#{GENERIC})"
+
+    PREPEND_STR = "http://".freeze
+    HOST = "(?:[a-zA-Z\\d](?:[-a-zA-Z\\d]*[a-zA-Z\\d])?\\.)+#{TLDS}".freeze
+
+    Card::Content::Chunk.register_class(
+      self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})#{HOST})\\b",
+            full_re: /\A#{::URI.regexp(SCHEMES)}/,
+            prepend_str: PREPEND_STR
+    )
+
+    # removes the prepended string from the unchanged match text
+    def process_text
+      @text = @text.sub(%r{^http://}, "")
+    end
+  end
+end

data/lib/card/content/chunk/view_stub.rb

@@ -0,0 +1,62 @@
+class Card
+  class Content
+    module Chunk
+      class ViewStub < Abstract
+        Chunk.register_class(
+          self,
+          prefix_re: Regexp.escape("(StUb"),
+          full_re: /\A\(StUb(.*?)sTuB\)/m,
+          idx_char: "("
+        )
+
+        def initialize text, content
+          super
+        end
+
+        def interpret match, _content
+          @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}"
+          end
+        end
+
+        def interpret_cast
+          @stub_hash[:cast].symbolize_keys!
+        end
+
+        def interpret_view_opts
+          @stub_hash[:view_opts].symbolize_keys!
+        end
+
+        def interpret_format_opts
+          hash = @stub_hash[:format_opts]
+          hash.symbolize_keys!
+          hash[:nest_mode] = hash[:nest_mode].to_sym
+          hash[:override] = hash[:override] == "true"
+          hash[:context_names].map!(&:to_name)
+        end
+
+        def process_chunk
+          @processed = format.stub_nest @stub_hash
+        end
+
+        def result
+          @processed
+        end
+      end
+    end
+  end
+end

data/set/abstract/code_file.rb

@@ -0,0 +1,100 @@
+class << self
+
+  def included host_class
+    track_mod_name host_class, caller
+  end
+
+  def track_mod_name host_class, caller
+    host_class.mattr_accessor :file_content_mod_name
+    host_class.file_content_mod_name = Card::Set.mod_name(caller)
+  end
+end
+
+# FIXME: these should abstracted and configured on the types
+# (same codes for `rake card:create:codefile`)
+
+# @return [Array<String>, String] the name of file(s) to be loaded
+def source_files
+  case type_id
+  when CoffeeScriptID then "#{codename}.js.coffee"
+  when JavaScriptID   then "#{codename}.js"
+  when CssID          then "#{codename}.css"
+  when ScssID         then "#{codename}.scss"
+  end
+end
+
+def source_dir
+  case type_id
+  when CoffeeScriptID, JavaScriptID then "lib/javascript"
+  when CssID, ScssID then "lib/stylesheets"
+  else
+    "lib"
+  end
+end
+
+def find_file filename
+  File.join(mod_path, source_dir, filename).tap do |file_path|
+    return nil if unknown_file? filename, file_path
+  end
+end
+
+def mod_path
+  modname = file_content_mod_name
+  if (match = modname.match(/^card-mod-(\w*)/))
+    modname = match[1]
+  end
+  Cardio::Mod.dirs.path modname
+end
+
+def unknown_file? filename, file_path
+  return false if File.exist? file_path
+
+  Rails.logger.info "couldn't locate file #{filename} at #{file_path}"
+  true
+end
+
+def existing_source_paths
+  Array.wrap(source_files).map do |filename|
+    find_file(filename)
+  end.compact
+end
+
+def source_changed? since:
+  existing_source_paths.any? { |path| ::File.mtime(path) > since }
+end
+
+def content
+  Array.wrap(source_files).map do |filename|
+    if (source_path = find_file filename)
+      Rails.logger.debug "reading file: #{source_path}"
+      File.read source_path
+    end
+  end.compact.join "\n"
+end
+
+format :html do
+  view :input do
+    "Content is stored in file and can't be edited."
+  end
+
+  view :file_size do
+    "#{card.name}: #{number_to_human_size card.content.bytesize}"
+  end
+
+  def short_content
+    fa_icon("exclamation-circle", class: "text-muted pr-2") +
+      wrap_with(:span, "file", class: "text-muted")
+  end
+
+  def standard_submit_button
+    multi_card_editor? ? super : ""
+  end
+end
+
+def coffee_files files
+  files.map { |f| "script_#{f}.js.coffee" }
+end
+
+def scss_files files
+  files.map { |f| "style_#{f}.scss" }
+end

data/set/abstract/haml_file.rb

@@ -0,0 +1,24 @@
+
+def self.included host_class
+  host_class.mattr_accessor :template_path
+  host_class.extend Card::Set::Format::HamlPaths
+  host_class.template_path = host_class.haml_template_path
+end
+
+def content
+  File.read template_path
+end
+
+format :html do
+  view :input do
+    "Content is managed by code and cannot be edited"
+  end
+
+  def haml_locals
+    {}
+  end
+
+  view :core do
+    haml card.content, haml_locals
+  end
+end

data/set/abstract/lock.rb

@@ -0,0 +1,26 @@
+def lock
+  was_already_locked = locked?
+  return if was_already_locked
+  Auth.as_bot do
+    lock!
+    yield
+  end
+ensure
+  unlock! unless was_already_locked
+end
+
+def lock_cache_key
+  "UPDATE-LOCK:#{key}"
+end
+
+def locked?
+  Card.cache.read lock_cache_key
+end
+
+def lock!
+  Card.cache.write lock_cache_key, true
+end
+
+def unlock!
+  Card.cache.write lock_cache_key, false
+end

data/set/abstract/templated_nests.rb

@@ -0,0 +1,7 @@
+format :html do
+  view :core do
+    with_nest_mode :template do
+      super()
+    end
+  end
+end

data/set/abstract/vendor_code_file.rb

@@ -0,0 +1,9 @@
+include_set Abstract::CodeFile
+
+def self.included host_class
+  Abstract::CodeFile.track_mod_name host_class, caller
+end
+
+def source_dir
+  "vendor"
+end

data/set/all/chunk.rb

@@ -0,0 +1,142 @@
+
+def chunks content, type, named=false
+  content ||= self.content
+  type ||= Card::Content::Chunk
+  all_chunks = Card::Content.new(content, self).find_chunks type
+  named ? all_chunks.select(&:referee_name) : all_chunks
+end
+
+def reference_chunks content=nil, named=true
+  chunks content, Card::Content::Chunk::Reference, named
+end
+
+# named=true rejects commented nests
+def nest_chunks content=nil, named=true
+  chunks content, Card::Content::Chunk::Nest, named
+end
+
+# named=true rejects external links (since the don't refer to a card name)
+def link_chunks content=nil, named=false
+  chunks content, Card::Content::Chunk::Link, named
+end
+
+def each_item_name_with_options content=nil
+  reference_chunks(content).each do |chunk|
+    options = chunk.respond_to?(:options) ? chunk.options : {}
+    yield chunk.referee_name, options
+  end
+end
+
+format do
+  def nest_chunks content=nil
+    content ||= _render_raw
+    card.nest_chunks content
+  end
+
+  def nested_cards content=nil
+    nest_chunks(content).map(&:referee_card).uniq
+  end
+
+  def edit_fields
+    voo.edit_structure || []
+  end
+
+  def nested_field_names content=nil
+    nest_chunks(content).map(&:referee_name).select { |n| field_name? n }
+  end
+
+  def nested_field_cards content=nil
+    nested_cards(content).select { |c| field_name? c.name }
+  end
+
+  def field_name? name
+    name.field_of? card.name
+  end
+
+  # @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 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_field_chunk &block
+    each_nested_chunk fields: true, &block
+  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 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 field_chunks chunks
+    chunks.select { |chunk| field_name?(chunk.referee_name) }
+  end
+
+  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 process_nested_chunks chunks, virtual, &block
+    chunks.each do |chunk|
+      process_nested_chunk chunk, virtual, &block
+    end
+  end
+
+  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_virtual_chunk chunk
+    subformat(chunk.referee_card).each_nested_field_chunk { |sub_chunk| yield sub_chunk }
+  end
+
+  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 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

data/set/all/templating.rb

@@ -0,0 +1,70 @@
+
+def is_template?
+  return @is_template unless @is_template.nil?
+
+  @is_template = name.trait_name? :structure, :default
+end
+
+def is_structure?
+  return @is_structure unless @is_structure.nil?
+
+  @is_structure = name.trait_name? :structure
+end
+
+def template
+  # currently applicable templating card.
+  # note that a *default template is never returned for an existing card.
+  @template ||= begin
+    @virtual = false
+
+    if new_card?
+      new_card_template
+    else
+      structure_rule_card
+    end
+  end
+end
+
+def default_type_id
+  Card.default_type_id
+end
+
+def new_card_template
+  default = rule_card :default, skip_modules: true
+  return default unless (structure = dup_structure default&.type_id)
+
+  @virtual = true if compound?
+  self.type_id = structure.type_id if assign_type_to?(structure)
+  structure
+end
+
+def dup_structure type_id
+  dup_card = dup
+  dup_card.type_id = type_id || default_type_id
+  dup_card.structure_rule_card
+end
+
+def assign_type_to? structure
+  return if type_id == structure.type_id
+  structure.assigns_type?
+end
+
+def assigns_type?
+  # needed because not all *structure templates govern the type of set members
+  # for example, X+*type+*structure governs all cards of type X,
+  # but the content rule does not (in fact cannot) have the type X.
+  pattern_code = Card.quick_fetch(name.trunk_name.tag_name)&.codename
+  return unless pattern_code && (set_class = Set::Pattern.find pattern_code)
+
+  set_class.assigns_type
+end
+
+def structure
+  template&.is_structure? ? template : nil
+end
+
+def structure_rule_card
+  return unless (card = rule_card :structure, skip_modules: true)
+
+  card.db_content&.strip == "_self" ? nil : card
+end

data/set/right/default.rb

@@ -0,0 +1,34 @@
+include_set Abstract::TemplatedNests
+
+format :html do
+  view :one_line_content do
+    raw = _render_raw
+    "#{card.type_name} : #{raw.present? ? raw : '<em>empty</em>'}"
+  end
+
+  def quick_form_opts
+    super.merge "data-update-foreign-slot":
+                ".card-slot.quick_edit-view.RIGHT-Xinput_type,"\
+                ".card-slot.quick_edit-view.RIGHT-Xcontent_option"\
+                ".card-slot.quick_edit-view.RIGHT-Xcontent_option_view"
+  end
+
+  def quick_editor
+    wrap_type_formgroup do
+      type_field class: "type-field rule-type-field _submit-on-select"
+    end +
+      wrap_content_formgroup do
+        text_field :content, class: "d0-card-content _submit-after-typing"
+      end
+  end
+
+  def visible_cardtype_groups
+    hash = ::Card::Set::Self::Cardtype::GROUP.slice("Text",  "Data", "Upload")
+    hash["Organize"] = ["List", "Pointer", "Link list", "Nest list"]
+    hash
+  end
+end
+
+def empty_ok?
+  true
+end

data/set/right/structure.rb

@@ -0,0 +1,72 @@
+include_set Abstract::TemplatedNests
+
+format :rss do
+  def raw_feed_items
+    [card]
+  end
+end
+
+format :html do
+  view :one_line_content do
+    "#{_render_type} : #{_render_raw}"
+  end
+
+  def visible_cardtype_groups
+    hash = ::Card::Set::Self::Cardtype::GROUP.slice("Text")
+    hash["Organize"] = ["Search", "Nest list"]
+    hash
+  end
+end
+
+event :update_structurees_references, :integrate,
+      when: :update_structurees_references? do
+  return unless (query = structuree_query)
+
+  Auth.as_bot do
+    query.run.each(&:update_references_out)
+  end
+end
+
+def update_structurees_references?
+  db_content_changed? || action == :delete
+end
+
+event :reset_cache_to_use_new_structure,
+      before: :update_structurees_references do
+  Card::Cache.reset_hard
+  Card::Cache.reset_soft
+end
+
+event :update_structurees_type, :finalize,
+      changed: :type_id, when: proc { |c| c.assigns_type? } do
+  update_structurees type_id: type_id
+end
+
+def structuree_names
+  return [] unless (query = structuree_query(return: :name))
+
+  Auth.as_bot do
+    query.run
+  end
+end
+
+def update_structurees args
+  # note that this is not smart about overriding templating rules
+  # for example, if someone were to change the type of a
+  # +*right+*structure rule that was overridden
+  # by a +*type plus right+*structure rule, the override would not be respected.
+  return unless (query = structuree_query(return: :id))
+
+  Auth.as_bot do
+    query.run.each_slice(100) do |id_batch|
+      Card.where(id: id_batch).update_all args
+    end
+  end
+end
+
+def structuree_query args={}
+  set_card = trunk
+  return unless set_card.type_id == SetID
+
+  set_card.fetch_query args
+end

data/set/self/default.rb

@@ -0,0 +1,2 @@
+setting_opts group: :templating, position: 2, rule_type_editable: true,
+             short_help_text: "type/content template for new cards"

data/set/self/structure.rb

@@ -0,0 +1,4 @@
+setting_opts group: :templating, position: 2, rule_type_editable: true,
+             short_help_text: "control card's content / structure",
+             help_text: "Controls cards' content / structure. "\
+                        "[[http://decko.org/formatting|more]]"

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-content
+version: !ruby/object:Gem::Version
+  version: 0.11.0
+platform: ruby
+authors:
+- Ethan McCutchen
+- Philipp Kühl
+- Gerry Gleason
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.101.0
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/card/content/chunk/escaped_literal.rb
+- lib/card/content/chunk/keep_escaped_literal.rb
+- lib/card/content/chunk/link.rb
+- lib/card/content/chunk/nest.rb
+- lib/card/content/chunk/query_reference.rb
+- lib/card/content/chunk/reference.rb
+- lib/card/content/chunk/uri.rb
+- lib/card/content/chunk/view_stub.rb
+- set/abstract/code_file.rb
+- set/abstract/haml_file.rb
+- set/abstract/lock.rb
+- set/abstract/templated_nests.rb
+- set/abstract/vendor_code_file.rb
+- set/all/chunk.rb
+- set/all/templating.rb
+- set/right/default.rb
+- set/right/structure.rb
+- set/self/default.rb
+- set/self/structure.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: content
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: card content handling
+test_files: []