card 1.16.14 → 1.16.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bff967a00719608171fe172a88f9e1d6771217a
-  data.tar.gz: 4d71791152c3662e0412e41986a395171bd457e3
+  metadata.gz: 7fb48f7c5eaa598c5193c212c044e187141188a8
+  data.tar.gz: e665cf776166d89cc00abdca8c2b51dab22db866
 SHA512:
-  metadata.gz: 86f5d9f8cb45509e260ffc05f38c2fb6af60c5f855ef90d285df72ffe18b4ce94aeeb4a4e8bb89397bec239bc97aecfd1026a758c1fa16e388156866019c1e63
-  data.tar.gz: 4fc615ab61f11cbe7afba28a165430e8bc833651e1cf537181963fffaf74cafea1f90a89a01b87658d0f7579ea659102cb9980f7bb7860c50ec3a74573d6413a
+  metadata.gz: 6a43a81fe986265ecd892f73f7c7e71726c02c038755dcb046d4c9f08fec8920bfc7e5c97063c1c890268810b1c0dae6afa2bfb9255e112df426f06d212a3185
+  data.tar.gz: bb876b6fc2b96a645747115ade4f95676b6f77ba0c6c450658eeafbfcea1b8377e349c3cadf67c3466e968facfc6be0609e2323bccc982cddd94e2f1ba538cd1

data/VERSION

@@ -1 +1 @@
-1.16.14
+1.16.15

data/db/migrate_core_cards/20150903130006_attachment_upload_cards.rb

@@ -2,8 +2,10 @@
 
 class AttachmentUploadCards < Card::CoreMigration
   def up
-    Card.create! name: '*new file', type: 'File', codename: 'new_file'
-    Card.create! name: '*new image', type: 'Image', codename: 'new_image'
+    Card.create! name: '*new file', type: 'File',
+                 codename: 'new_file', empty_ok: true
+    Card.create! name: '*new image', type: 'Image',
+                 codename: 'new_image', empty_ok: true
 
     if js_output = Card['*all+*script+*machine output']
       #perhaps too narrow?

data/lib/card/auth.rb

@@ -54,8 +54,9 @@ class Card
       def find_by_token token
         Auth.as_bot do
           Card.search(
-            right_id: Card::AccountID,
-            right_plus: [{ id: Card::TokenID }, { content: token.strip }]
+            { right_id: Card::AccountID,
+              right_plus: [{ id: Card::TokenID }, { content: token.strip }]
+              }, 'find +*account card by token'
           ).first
         end
       end
@@ -70,8 +71,9 @@ class Card
         email = email.strip.downcase
         Auth.as_bot do
           Card.search(
-            right_id: Card::AccountID,
-            right_plus: [{ id: Card::EmailID }, { content: email }]
+            { right_id: Card::AccountID,
+              right_plus: [{ id: Card::EmailID }, { content: email }]
+              }, "find +*account for email(#{email})"
           ).first
         end
       end
@@ -211,12 +213,15 @@ class Card
       # PERMISSIONS
 
       def createable_types
-        type_names = Auth.as_bot do
-          Card.search type: Card::CardtypeID, return: :name,
-                      not: {
-                        codename: ['in'] + Card.config.non_createable_types
-                      }
-        end
+        type_names =
+          Auth.as_bot do
+            Card.search(
+              { type: Card::CardtypeID, return: :name,
+                not: { codename: ['in'] + Card.config.non_createable_types } },
+              'find createable types'
+            )
+          end
+
         type_names.select do |name|
           Card.new(type: name).ok? :create
         end.sort

data/lib/card/codename.rb

@@ -4,16 +4,14 @@ require_dependency 'card/name'
 
 class Card
   class Codename
-
-    @@codehash=nil
+    @@codehash = nil
 
     class << self
       # returns codename for id and vice versa.  not in love with this api --efm
       def [] key
-        if !key.nil?
-          key = key.to_sym unless Integer===key
-          codehash[key]
-        end
+        return if key.nil?
+        key = key.to_sym unless key.is_a? Integer
+        codehash[key]
       end
 
       def codehash
@@ -25,41 +23,48 @@ class Card
         cache.write 'CODEHASH', nil
       end
 
-      #only used in migration
+      # only used in migration
       def bootdata hash
         @@codehash = hash
       end
 
-
       private
 
       def cache
         Card::Cache[Codename]
       end
 
+      def each_codenamed_card
+        sql = 'select id, codename from cards where codename is not NULL'
+        ActiveRecord::Base.connection.select_all(sql).each do |row|
+          yield row['codename'].to_sym, row['id'].to_i
+        end
+      end
+
+      def check_duplicates codehash, codename, card_id
+        # FIXME: remove duplicate checks here; should be caught upon creation
+        return unless codehash.has_key?(codename) || codehash.has_key?(card_id)
+        warn "dup code ID:#{card_id} (#{codehash[codename]}), " \
+             "CD:#{codename} (#{codehash[card_id]})"
+      end
+
       def load_hash
         @@codehash = cache.read('CODEHASH') || begin
           codehash = {}
-          sql = 'select id, codename from cards where codename is not NULL'
-          ActiveRecord::Base.connection.select_all(sql).each do |row|
-            #FIXME: remove duplicate checks, put them in other tools
-            code, cid = row['codename'].to_sym, row['id'].to_i
-            if codehash.has_key?(code) or codehash.has_key?(cid)
-              warn "dup code ID:#{cid} (#{codehash[code]}), CD:#{code} (#{codehash[cid]})"
-            end
-            codehash[code] = cid; codehash[cid] = code
+          each_codenamed_card do |codename, card_id|
+            check_duplicates codehash, codename, card_id
+            codehash[codename] = card_id
+            codehash[card_id] = codename
           end
           cache.write 'CODEHASH', codehash
         end
       end
     end
-
   end
 
-
   def self.const_missing const
-    if const.to_s =~ /^([A-Z]\S*)ID$/ and code=$1.underscore.to_sym
-      if card_id = Codename[code]
+    if const.to_s =~ /^([A-Z]\S*)ID$/ && (code = $1.underscore.to_sym)
+      if (card_id = Codename[code])
         const_set const, card_id
       else
         raise "Missing codename #{code} (#{const})"
@@ -68,5 +73,4 @@ class Card
       super
     end
   end
-
 end

data/lib/card/content.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-# TODO move Card::Chunk to Card::Content::Chunk...
+# TODO: move Card::Chunk to Card::Content::Chunk...
 require_dependency 'card/chunk'
 
 class Card
@@ -9,7 +9,7 @@ class Card
 
     def initialize content, format_or_card, opts={}
       @format =
-        if Card===format_or_card
+        if format_or_card.is_a?(Card)
           Format.new format_or_card, format: nil
         else
           format_or_card
@@ -32,10 +32,10 @@ class Card
 
     def to_s
       case __getobj__
-      when Array;    map(&:to_s)*''
-      when String;   __getobj__
-      when NilClass; '' #raise "Nil Card::Content"
-      else           __getobj__.to_s
+      when Array    then map(&:to_s) * ''
+      when String   then __getobj__
+      when NilClass then '' # raise "Nil Card::Content"
+      else               __getobj__.to_s
       end
     end
 
@@ -46,16 +46,17 @@ class Card
     def each_chunk
       return enum_for(:each_chunk) unless block_given?
       case __getobj__
-        when Hash;   each { |k,v| yield v if Chunk::Abstract===v }
-        when Array;  each { |e|   yield e if Chunk::Abstract===e }
-        when String; # strings are all parsed in self, so no chunks in a String
-        else
-          Rails.logger.warn "error self is unrecognized type #{self.class} #{self.__getobj__.class}"
+      when Hash  then each_value { |v| yield v if v.is_a?(Chunk::Abstract) }
+      when Array then each       { |e| yield e if e.is_a?(Chunk::Abstract) }
+      when String # noop. strings are parsed in self, so no chunks in a String
+      else
+        Rails.logger.warn msg, 'error self is unrecognized type'\
+                                " #{self.class} #{__getobj__.class}"
       end
     end
 
     def find_chunks chunk_type
-      each_chunk.select { |chunk| chunk.kind_of?(chunk_type) }
+      each_chunk.select { |chunk| chunk.is_a?(chunk_type) }
     end
 
     def process_content_object &block
@@ -66,45 +67,65 @@ class Card
     def parse_content content
       @chunks = []
 
-      if String===content
+      if content.is_a? String
         position = last_position = 0
         prefix_regexp = Chunk.get_prefix_regexp chunk_list
         interval_string = ''
 
-        while prefix_match = content[position..-1].match( prefix_regexp )
-          prefix = prefix_match[0]                                                 # prefix of matched chunk
-          chunk_start = prefix_match.begin(0) + position                           # content index of beginning of chunk
-
-          if prefix_match.begin(0) > 0                                             # if matched chunk is not beginning of test string
-            interval_string += content[ position..chunk_start-1 ]                  # hold onto the non-chunk part of the string
+        while (prefix_match = content[position..-1].match(prefix_regexp))
+          prefix = prefix_match[0]
+          # prefix of matched chunk
+          chunk_start = prefix_match.begin(0) + position
+          # content index of beginning of chunk
+          if prefix_match.begin(0) > 0
+            # if matched chunk is not beginning of test string
+            interval_string += content[position..chunk_start - 1]
+            # hold onto the non-chunk part of the string
           end
 
-          chunk_class = Chunk.find_class_by_prefix prefix                          # get the chunk class from the prefix
-          match, offset = chunk_class.full_match content[chunk_start..-1], prefix  # see whether the full chunk actually matches (as opposed to bogus prefix)
-          context_ok = chunk_class.context_ok? content, chunk_start                # make sure there aren't contextual reasons for ignoring this chunk
-          position = chunk_start                                                   # move scanning position up to beginning of chunk
-
-          if match                                                                 # we have a chunk match
-            position += ( match.end(0) - offset.to_i )                             # move scanning position up to end of chunk
-            if context_ok                                                          #
-              @chunks << interval_string if interval_string.size > 0                # add the nonchunk string to the chunk list
-              @chunks << chunk_class.new( match, self )                             # add the chunk to the chunk list
-              interval_string = ''                                                 # reset interval string for next go-round
-              last_position = position                                             # note that the end of the chunk was the last place where a chunk was found (so far)
+          chunk_class = Chunk.find_class_by_prefix prefix
+          # get the chunk class from the prefix
+          match, offset =
+            chunk_class.full_match content[chunk_start..-1], prefix
+          # see whether the full chunk actually matches
+          # (as opposed to bogus prefix)
+          context_ok = chunk_class.context_ok? content, chunk_start
+          # make sure there aren't contextual reasons for ignoring this chunk
+          position = chunk_start
+          # move scanning position up to beginning of chunk
+
+          if match
+            # we have a chunk match
+            position += (match.end(0) - offset.to_i)
+            # move scanning position up to end of chunk
+            if context_ok
+              @chunks << interval_string if interval_string.size > 0
+              # add the nonchunk string to the chunk list
+              @chunks << chunk_class.new(match, self)
+              # add the chunk to the chunk list
+              interval_string = ''
+              # reset interval string for next go-round
+              last_position = position
+              # note that the end of the chunk was the last place where a
+              # chunk was found (so far)
             end
           else
-            position += 1                                                          # no match.  look at the next character
+            position += 1
+            # no match.  look at the next character
           end
 
           if !match || !context_ok
-            interval_string += content[chunk_start..position-1]                    # moving beyond the alleged chunk.  append failed string to "nonchunk" string
+            interval_string += content[chunk_start..position - 1]
+            # moving beyond the alleged chunk.
+            # append failed string to "nonchunk" string
           end
         end
       end
 
       if chunks.any?
         if last_position < content.size
-          remainder = content[ last_position..-1]                                  # handle any leftover nonchunk string at the end of content
+          remainder = content[last_position..-1]
+          # handle any leftover nonchunk string at the end of content
           @chunks << remainder
         end
         chunks
@@ -113,9 +134,6 @@ class Card
       end
     end
 
-
-
-
     ALLOWED_TAGS = {}
     %w{
       br i b pre cite caption strong em ins sup sub del ol hr ul li p
@@ -124,7 +142,7 @@ class Card
 
     # allowed attributes
     ALLOWED_TAGS.merge!(
-      'a' => ['href', 'title', 'target' ],
+      'a' => ['href', 'title', 'target'],
       'img' => ['src', 'alt', 'title'],
       'code' => ['lang'],
       'blockquote' => ['cite']
@@ -134,85 +152,99 @@ class Card
       ALLOWED_TAGS['table'] += %w[ cellpadding align border cellspacing ]
     end
 
-    ALLOWED_TAGS.each_key {|k|
+    ALLOWED_TAGS.each_key do |k|
       ALLOWED_TAGS[k] << 'class'
       ALLOWED_TAGS[k] << 'style' if Card.config.allow_inline_styles
       ALLOWED_TAGS[k]
-    }
+    end
     ALLOWED_TAGS
 
-    ATTR_VALUE_RE = [ /(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/ ]
+    ATTR_VALUE_RE = [/(?<=^')[^']+(?=')/, /(?<=^")[^"]+(?=")/, /\S+/]
 
     class << self
-
       ## Method that cleans the String of HTML tags
       ## and attributes outside of the allowed list.
 
       # this has been hacked for card to allow classes if
       # the class begins with "w-"
-      def clean!( string, tags = ALLOWED_TAGS )
-        string.gsub( /<(\/*)(\w+)([^>]*)>/ ) do
+      def clean!(string, tags=ALLOWED_TAGS)
+        string.gsub(/<(\/*)(\w+)([^>]*)>/) do
           raw = $~
           tag = raw[2].downcase
-          if attrs = tags[tag]
-            "<#{raw[1]}#{
+          if (attrs = tags[tag])
+            html_attribs =
               attrs.inject([tag]) do |pcs, attr|
-                q='"'
-                rest_value=nil
+                q = '"'
+                rest_value = nil
                 if raw[3] =~ /\b#{attr}\s*=\s*(?=(.))/i
                   rest_value = $'
-                  idx = %w{' "}.index($1) and q = $1
-                  re = ATTR_VALUE_RE[ idx || 2 ]
-                  if match = rest_value.match(re)
+                  (idx = %w{' "}.index($1)) && (q = $1)
+                  re = ATTR_VALUE_RE[idx || 2]
+                  if (match = rest_value.match(re))
                     rest_value = match[0]
                     if attr == 'class'
-                      rest_value = rest_value.split(/\s+/).find_all {|s| s=~/^w-/i}*' '
+                      rest_value =
+                        rest_value.split(/\s+/).select do |s|
+                          s =~ /^w-/i
+                        end * ' '
                     end
                   end
                 end
                 pcs << "#{attr}=#{q}#{rest_value}#{q}" unless rest_value.blank?
                 pcs
               end * ' '
-            }>"
+            "<#{raw[1]}#{html_attribs}>"
           else
-            " "
+            ' '
           end
         end.gsub(/<\!--.*?-->/, '')
       end
 
       if Card.config.space_last_in_multispace
-        def clean_with_space_last! string, tags = ALLOWED_TAGS
-          clean_without_space_last!(string, tags).gsub(/(?:^|\b) ((?:&nbsp;)+)/, '\1 ')
+        def clean_with_space_last! string, tags=ALLOWED_TAGS
+          cwo = clean_without_space_last!(string, tags)
+          cwo.gsub(/(?:^|\b) ((?:&nbsp;)+)/, '\1 ')
         end
         alias_method_chain :clean!, :space_last
       end
-      def truncatewords_with_closing_tags(input, words = 25, truncate_string = "...")
+
+      def truncatewords_with_closing_tags input, words=25, truncate_string='...'
         if input.nil? then return end
         wordlist = input.to_s.split
         l = words.to_i - 1
         l = 0 if l < 0
-        wordstring = wordlist.length > l ? wordlist[0..l].join(" ") : input.to_s
+        wordstring = wordlist.length > l ? wordlist[0..l].join(' ') : input.to_s
         # nuke partial tags at end of snippet
-        wordstring.gsub!(/(<[^\>]+)$/,'')
+        wordstring.gsub!(/(<[^\>]+)$/, '')
 
         tags = []
 
         # match tags with or without self closing (ie. <foo />)
-        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\>/).each { |t| tags.unshift(t[0]) }
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\>/).each do |t|
+          tags.unshift(t[0])
+        end
         # match tags with self closing and mark them as closed
-        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\/\>/).each { |t| if !(x=tags.index(t[0])).nil? then tags.slice!(x) end }
+        wordstring.scan(/\<([^\>\s\/]+)[^\>]*?\/\>/).each do |t|
+          if !(x = tags.index(t[0])).nil? then tags.slice!(x) end
+        end
         # match close tags
-        wordstring.scan(/\<\/([^\>\s\/]+)[^\>]*?\>/).each { |t|  if !(x=tags.rindex(t[0])).nil? then tags.slice!(x) end  }
+        wordstring.scan(/\<\/([^\>\s\/]+)[^\>]*?\>/).each do |t|
+          if !(x = tags.rindex(t[0])).nil? then tags.slice!(x) end
+        end
 
-        tags.each {|t| wordstring += "</#{t}>" }
+        tags.each { |t| wordstring += "</#{t}>" }
 
-        wordstring +='<span class="closed-content-ellipses">...</span>' if wordlist.length > l
-    #    wordstring += '...' if wordlist.length > l
-        wordstring.gsub! /<[\/]?br[\s\/]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
-        wordstring.gsub! /<[\/]?p[^>]*>/, ' ' ## Also a hack -- get rid of <br>'s -- they make line view ugly.
+        if wordlist.length > l
+          wordstring += '<span class="closed-content-ellipses">...</span>'
+        end
+
+        # wordstring += '...' if wordlist.length > l
+        wordstring.gsub! /<[\/]?br[\s\/]*>/, ' '
+        # Also a hack -- get rid of <br>'s -- they make line view ugly.
+        wordstring.gsub! /<[\/]?p[^>]*>/, ' '
+        ## Also a hack -- get rid of <br>'s -- they make line view ugly.
         wordstring
       end
-
     end
   end
 end