card 1.18.6 → 1.19.0

data/mod/carrierwave/set/type/image.rb

@@ -0,0 +1,89 @@
+attachment :image, uploader: CarrierWave::ImageCardUploader
+
+include File::SelectedAction
+
+format do
+  include File::Format
+
+  view :closed_content do |_args|
+    _render_core size: :icon
+  end
+
+  view :source do |args|
+    style =
+      case
+      when @mode == :closed then :icon
+      when args[:size]    then args[:size].to_sym
+      when main?          then :large
+      else :medium
+      end
+    style = :original if style.to_sym == :full
+    if style == :original
+      card.image.url
+    else
+      card.image.versions[style].url
+    end
+  end
+end
+
+format :html do
+  include File::HtmlFormat
+
+  view :core do |args|
+    handle_source args do |source|
+      if source == "missing"
+        "<!-- image missing #{@card.name} -->"
+      else
+        image_tag(source)
+      end
+    end
+  end
+
+  def preview args
+    if !card.new_card? || card.preliminary_upload?
+      content_tag :div, _render_core(args.merge(size: :medium)).html_safe,
+                  class: "attachment-preview",
+                  id: "#{card.attachment.filename}-preview"
+    end
+  end
+
+  view :content_changes do |args|
+    out = ""
+    size = args[:diff_type] == :summary ? :icon : :medium
+    if !args[:hide_diff] && args[:action] &&
+       (last_change = card.last_change_on(:db_content, before: args[:action]))
+      card.selected_action_id = last_change.card_action_id
+      out << Card::Content::Diff.render_deleted_chunk(_render_core(size: size))
+    end
+    card.selected_action_id = args[:action].id
+    out << Card::Content::Diff.render_added_chunk(_render_core(size: size))
+    out
+  end
+end
+
+format :css do
+  view :core do |_args|
+    render_source
+  end
+
+  view :content do |_args|  # why is this necessary?
+    render_core
+  end
+end
+
+format :file do
+  include File::FileFormat
+
+  view :style do |args|  # should this be in model?
+    ["", "full"].member?(args[:style].to_s) ? :original : args[:style]
+  end
+
+  def selected_file_version
+    style = _render_style(style: params[:size]).to_sym
+    if style && style != :original
+      card.attachment.versions[style]
+    else
+      card.attachment
+    end
+  end
+end

data/mod/core/chunk/include.rb

@@ -0,0 +1,129 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency File.expand_path("../reference", __FILE__)
+
+class Card
+  class Content
+    module Chunk
+      # Handler for nest chunks: {{example}}
+      class Include < Reference
+        cattr_reader :options
+        @@options = ::Set.new [
+          :inc_name,   # name as used in nest
+          :inc_syntax, # full nest syntax
+          :items,      # handles pipe-based recursion
+
+          # _conventional options_
+          :view, :type, :title, :params, :variant,
+          :size,        # images only
+          :hide, :show, # affects optional rendering
+          :structure    # override raw_content
+        ]
+        attr_reader :options
+        DEFAULT_OPTION = :view # a value without a key is interpreted as view
+
+        Chunk.register_class(self, prefix_re: '\\{\\{',
+                                   full_re:    /^\{\{([^\}]*)\}\}/,
+                                   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 =~ /^\#/
+            @process_chunk = name =~ /^\#\#/ ? "" : visible_comment(in_brackets)
+          else
+            @options = interpret_options.merge inc_name: name,
+                                               inc_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 }
+          style_hash = {}
+          option_string_to_hash list_string, options_hash, style_hash
+          style_hash_to_string options_hash, style_hash
+          options_hash
+        end
+
+        def option_string_to_hash list_string, options_hash, style_hash
+          each_option(list_string) do |key, value|
+            key = key.to_sym
+            if key == :item
+              options_hash[:items] ||= {}
+              options_hash[:items][:view] = value
+            elsif @@options.include? key
+              options_hash[key] = value
+            else
+              style_hash[key] = value
+            end
+          end
+        end
+
+        def style_hash_to_string options_hash, style_hash
+          return if style_hash.empty?
+          options_hash[:style] = style_hash.map do |key, value|
+            CGI.escapeHTML "#{key}:#{value};"
+          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 = yield @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 =~ /\|/
+            @text.sub! "|", "|#{view};"
+          else
+            @text.sub! "}}", "|#{view}}}"
+          end
+        end
+
+        private
+
+        def each_option attr_string
+          return if attr_string.blank?
+          attr_string.strip.split(";").each do |pair|
+            value, key = pair.split(":").reverse
+            key ||= self.class::DEFAULT_OPTION.to_s
+            yield key.strip, value.strip
+          end
+        end
+      end
+    end
+  end
+end

data/mod/core/chunk/link.rb

@@ -0,0 +1,96 @@
+# -*- 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:   /^\[\[([^\]]+)\]\]/,
+                                        idx_char:  "["
+    def reference_code
+      CODE
+    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
+
+      @link_text = objectify @link_text
+      if target =~ %r{/|mailto:}
+        @explicit_link = objectify target
+      else
+        @name = target
+      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}" # had to do this to create new string?!
+      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
+
+    def render_link
+      @link_text = render_obj @link_text
+
+      if @explicit_link
+        @explicit_link = render_obj @explicit_link
+        format.web_link @explicit_link, text: @link_text
+      elsif @name
+        format.card_link referee_name, text: @link_text,
+                                       known: referee_card.send_if(:known?)
+      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
+
+      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 old_name.to_name == @link_text
+        @link_text = new_name
+      end
+
+      @text = if @link_text.nil?
+                "[[#{referee_name}]]"
+              else
+                "[[#{referee_name}|#{@link_text}]]"
+              end
+    end
+  end
+end

data/mod/core/chunk/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 = { "[" => /^\\\[\[[^\]]*\]\]/,
+                    "{" => /^\\\{\{[^\}]*\}\}/ }.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(/^\\(.)/, '<span>\\1</span>')
+        end
+      end
+    end
+  end
+end

data/mod/core/chunk/query_reference.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency File.expand_path("../reference", __FILE__)
+
+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
+
+  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_name)
+    )
+
+    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:   /"([^"]+)"/,
+            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
+        match, offset = super(content, prefix)
+        return unless match && !QUERY_KEYWORDS.include?(match[1].to_name)
+        [match, offset]
+      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

data/mod/core/chunk/uri.rb

@@ -0,0 +1,144 @@
+# -*- 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: /^#{::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_opts = { text: process_text }
+      "#{format.web_link(@link_text, link_opts)}#{@trailing_punctuation}"
+    end
+  end
+
+  # FIXME: DRY, merge these two into one class
+  class EmailURI < URI
+    PREPEND_STR = "mailto:".freeze
+    EMAIL = '[a-zA-Zd](?:[-a-zA-Zd]*[a-zA-Zd])?\\@'.freeze
+
+    Card::Content::Chunk.register_class(
+      self, prefix_re: "(?:(?!#{REJECTED_PREFIX_RE})#{EMAIL})\\b",
+            full_re: /^#{::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: /^#{::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